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

codex/views/reader/page.py

@@ -1,7 +1,9 @@
 """Views for reading comic books."""
 
+from io import BytesIO
+
 from comicbox.box import Comicbox
-from django.http import HttpResponse
+from django.http.response import StreamingHttpResponse
 from drf_spectacular.types import OpenApiTypes
 from drf_spectacular.utils import OpenApiParameter, extend_schema
 from rest_framework.exceptions import NotFound
@@ -11,9 +13,13 @@ from codex.logger.logging import get_logger
 from codex.models import Comic
 from codex.views.bookmark import BookmarkBaseView
 from codex.views.const import FALSY
+from codex.views.util import chunker
 
 LOG = get_logger(__name__)
-PDF_MIME_TYPE = "application/pdf"
+_PDF_MIME_TYPE = "application/pdf"
+# Most pages seem to be 2.5 Mb
+# largest pages I've seen were 9 Mb
+_PAGE_CHUNK_SIZE = (1024**2) * 3  # 3 Mb
 
 
 class IgnoreClientContentNegotiation(BaseContentNegotiation):
@@ -63,11 +69,15 @@ class ReaderPageView(BookmarkBaseView):
         page = self.kwargs.get("page")
         to_pixmap = self.request.GET.get("pixmap", "").lower() not in FALSY
         if comic.file_type == Comic.FileType.PDF.value and not to_pixmap:
-            content_type = PDF_MIME_TYPE
+            content_type = _PDF_MIME_TYPE
         else:
             content_type = self.content_type
+
         with Comicbox(comic.path) as cb:
             page_image = cb.get_page_by_index(page, to_pixmap=to_pixmap)
+        if not page_image:
+            page_image = b""
+
         return page_image, content_type
 
     @extend_schema(
@@ -77,7 +87,7 @@ class ReaderPageView(BookmarkBaseView):
         ],
         responses={
             (200, content_type): OpenApiTypes.BINARY,
-            (200, PDF_MIME_TYPE): OpenApiTypes.BINARY,
+            (200, _PDF_MIME_TYPE): OpenApiTypes.BINARY,
         },
     )
     def get(self, *_args, **_kwargs):
@@ -98,4 +108,5 @@ class ReaderPageView(BookmarkBaseView):
             LOG.warning(exc)
             raise NotFound(detail="comic page not found") from exc
         else:
-            return HttpResponse(page_image, content_type=content_type)
+            page_chunker = chunker(BytesIO(page_image), _PAGE_CHUNK_SIZE)
+            return StreamingHttpResponse(page_chunker, content_type=content_type)

codex/views/reader/reader.py

@@ -1,214 +1,29 @@
 """Views for reading comic books."""
 
 from comicbox.box import Comicbox
-from django.db.models import F, IntegerField, Value
 from django.urls import reverse
-from drf_spectacular.types import OpenApiTypes
-from drf_spectacular.utils import OpenApiParameter, extend_schema
+from drf_spectacular.utils import extend_schema
 from rest_framework.exceptions import NotFound
 from rest_framework.response import Response
 
 from codex.librarian.importer.tasks import LazyImportComicsTask
 from codex.librarian.mp_queue import LIBRARIAN_QUEUE
 from codex.logger.logging import get_logger
-from codex.models import AdminFlag, Bookmark, Comic
-from codex.serializers.reader import ReaderComicsSerializer
+from codex.serializers.reader import ReaderComicsSerializer, ReaderViewInputSerializer
 from codex.serializers.redirect import ReaderRedirectSerializer
-from codex.views.bookmark import BookmarkBaseView
-from codex.views.session import BrowserSessionViewBase
+from codex.views.reader.arcs import ReaderArcsView
+from codex.views.util import pop_name
 
 LOG = get_logger(__name__)
 
 
-class ReaderView(BookmarkBaseView):
+class ReaderView(ReaderArcsView):
     """Get info for displaying comic pages."""
 
     serializer_class = ReaderComicsSerializer
 
-    SETTINGS_ATTRS = ("fit_to", "two_pages", "reading_direction")
-    _COMIC_FIELDS = (
-        "file_type",
-        "issue_number",
-        "issue_suffix",
-        "page_count",
-        "series",
-        "volume",
-        "reading_direction",
-        "updated_at",
-    )
-    _VALID_ARC_GROUPS = frozenset({"f", "s", "a"})
-
-    def _get_comics_list(self):
-        """Get the reader naviation group filter."""
-        select_related = ("series", "volume")
-        prefetch_related = ()
-
-        arc_group = self.params.get("arc_group")
-        if arc_group == "a":
-            # for story arcs
-            rel = "story_arc_numbers__story_arc"
-            fields = self._COMIC_FIELDS
-            arc_name_rel = "story_arc_numbers__story_arc__name"
-            arc_pk_rel = "story_arc_numbers__story_arc__pk"
-            prefetch_related = (*prefetch_related, "story_arc_numbers__story_arc")
-            arc_index = F("story_arc_numbers__number")
-            ordering = ("arc_index", "date", *Comic.ORDERING)
-            arc_pk_select_related = ()
-            arc_pk_only = ("pk",)
-        elif arc_group == self.FOLDER_GROUP:
-            # folder mode
-            rel = "parent_folder"
-            fields = (*self._COMIC_FIELDS, "parent_folder")
-            arc_pk_rel = "parent_folder__pk"
-            arc_name_rel = "parent_folder__name"
-            select_related = (*select_related, "parent_folder")
-            arc_index = Value(None, IntegerField())
-            ordering = ("path", "pk")
-            arc_pk_select_related = ("parent_folder",)
-            arc_pk_only = arc_pk_select_related
-        else:
-            # browser mode.
-            rel = "series"
-            fields = self._COMIC_FIELDS
-            arc_pk_rel = "series__pk"
-            arc_name_rel = "series__name"
-            arc_index = Value(None, IntegerField())
-            ordering = Comic.ORDERING
-            arc_pk_select_related = ("series",)
-            arc_pk_only = arc_pk_select_related
-
-        arc_pk = self.params.get("arc_pk")
-        if not arc_pk:
-            # Get the correct arc/folder/series if not submitted with a post.
-            pk = self.kwargs.get("pk")
-            arc_pk_qs = Comic.objects.filter(pk=pk)
-            arc_pk_qs = arc_pk_qs.select_related(*arc_pk_select_related)
-            arc_pk_qs = arc_pk_qs.prefetch_related(*prefetch_related)
-            arc_pk_comic = (
-                arc_pk_qs.annotate(arc_pk=F(arc_pk_rel)).only(*arc_pk_only).first()
-            )
-            arc_pk = arc_pk_comic.arc_pk  # type: ignore
-
-        group_acl_filter = self.get_group_acl_filter(Comic)
-        nav_filter = {rel: arc_pk}
-
-        qs = (
-            Comic.objects.filter(group_acl_filter)
-            .filter(**nav_filter)
-            .select_related(*select_related)
-            .prefetch_related(*prefetch_related)
-            .only(*fields)
-            .annotate(
-                series_name=F("series__name"),
-                volume_name=F("volume__name"),
-                issue_count=F("volume__issue_count"),
-            )
-            .annotate(
-                arc_pk=F(arc_pk_rel),
-                arc_name=F(arc_name_rel),
-                arc_index=arc_index,
-            )
-            .annotate(mtime=F("updated_at"))
-        )
-
-        return qs.order_by(*ordering)
-
-    def _append_with_settings(self, book, bookmark_filter):
-        """Get bookmarks and filename and append to book list."""
-        book.settings = (
-            Bookmark.objects.filter(**bookmark_filter, comic=book)
-            .only(*self.SETTINGS_ATTRS)
-            .first()
-        )
-        return book
-
-    def _get_book_collection(self):
-        """Get the -1, +1 window around the current issue.
-
-        Uses iteration in python. There are some complicated ways of
-        doing this with __gt[0] & __lt[0] in the db, but I think they
-        might be even more expensive.
-
-        Yields 1 to 3 books
-        """
-        comics = self._get_comics_list()
-        bookmark_filter = self.get_bookmark_filter()
-        books = {}
-        prev_book = None
-        pk = self.kwargs.get("pk")
-        for index, book in enumerate(comics):
-            if books:
-                # after match set next comic and break
-                books["next"] = self._append_with_settings(book, bookmark_filter)
-                break
-            if book.pk == pk:
-                # first match. set previous and current comic
-                if prev_book:
-                    books["prev"] = self._append_with_settings(
-                        prev_book, bookmark_filter
-                    )
-                # create extra current book attrs:
-                if book.arc_index is None:  # type: ignore
-                    book.arc_index = index + 1  # type: ignore
-                book.filename = book.filename()  # type: ignore
-
-                books["current"] = self._append_with_settings(book, bookmark_filter)
-            else:
-                # Haven't matched yet, so set the previous comic
-                prev_book = book
-        return books, comics.count()
-
-    def _get_folder_arc(self, book):
-        """Create the folder arc."""
-        efv_flag = (
-            AdminFlag.objects.only("on")
-            .get(key=AdminFlag.FlagChoices.FOLDER_VIEW.value)
-            .on
-        )
-
-        if efv_flag:
-            folder_arc = {
-                "group": self.FOLDER_GROUP,
-                "pk": book.parent_folder.pk,
-                "name": book.parent_folder.name,
-            }
-        else:
-            folder_arc = None
-        return folder_arc
-
-    def _get_arcs(self, book):
-        """Get all series/folder/story arcs."""
-        # create top arcs
-        folder_arc = self._get_folder_arc(book)
-        series_arc = {"group": "s", "pk": book.series.pk, "name": book.series.name}
-
-        # order top arcs
-        top_group = self.params.get("top_group")
-        if top_group == self.FOLDER_GROUP and folder_arc:
-            arc = folder_arc
-            other_arc = series_arc
-        else:
-            arc = series_arc
-            other_arc = folder_arc
-
-        arcs = []
-        arcs.append(arc)
-        if other_arc:
-            arcs.append(other_arc)
-
-        # story arcs
-        sas = []
-        for san in book.story_arc_numbers.all():
-            sa = san.story_arc
-            arc = {
-                "group": "a",
-                "pk": sa.pk,
-                "name": sa.name,
-            }
-            sas.append(arc)
-        sas = sorted(sas, key=lambda x: x["name"])
-        arcs += sas
-        return arcs
+    SESSION_KEY = "reader"
+    TARGET = "reader"
 
     def _raise_not_found(self):
         """Raise not found exception."""
@@ -247,7 +62,7 @@ class ReaderView(BookmarkBaseView):
     def get_object(self):
         """Get the previous and next comics in a group or story arc."""
         # Books
-        books, arc_count = self._get_book_collection()
+        books = self.get_book_collection()
 
         current = books.get("current")
         if not current:
@@ -264,57 +79,28 @@ class ReaderView(BookmarkBaseView):
         }
 
         # Arcs
-        arcs = self._get_arcs(current)
+        arcs, mtime = self.get_arcs(current)
 
-        arc_group = self.params.get("arc_group")
-        arc = {
-            "group": arc_group,
-            "pk": current.arc_pk,  # type: ignore
-            "index": current.arc_index,  # type: ignore
-            "count": arc_count,
-        }
+        arc = self.params.get("arc", {})
+        if not arc.get("group"):
+            arc["group"] = current.arc_group  # type: ignore
+        if not arc.get("pks"):
+            arc["pks"] = (current.arc_pk,)  # type: ignore
+        arc["index"] = current.arc_index  # type:ignore
+        arc["count"] = current.arc_count  # type: ignore
+
+        close_route = self.get_last_route()
+        close_route = pop_name(close_route)
 
         return {
             "books": books,
             "arcs": arcs,
             "arc": arc,
+            "close_route": close_route,
+            "mtime": mtime,
         }
 
-    def _parse_params(self):
-        data = self.request.GET
-
-        # PARAMS
-        session = self.request.session.get(BrowserSessionViewBase.SESSION_KEY, {})
-        top_group = session.get("top_group", "s")
-        arc_group = data.get("arcGroup")
-        if not arc_group:
-            arc_group = top_group
-
-        if arc_group not in self._VALID_ARC_GROUPS:
-            arc_group = "s"
-
-        arc_pk = data.get("arcPk")
-        if arc_pk is not None:
-            arc_pk = int(arc_pk)
-        elif top_group == "a":
-            last_route = session.get("route", {})
-            arc_pk = last_route.get("pk")
-
-        params = {
-            "arc_group": arc_group,
-            "arc_pk": arc_pk,
-            "top_group": top_group,
-        }
-        self.params = params
-
-    @extend_schema(
-        parameters=[
-            OpenApiParameter(
-                "arcGroup", OpenApiTypes.STR, enum=sorted(_VALID_ARC_GROUPS)
-            ),
-            OpenApiParameter("arcPk", OpenApiTypes.INT),
-        ]
-    )
+    @extend_schema(parameters=[ReaderViewInputSerializer])
     def get(self, *args, **kwargs):
         """Get the book info."""
         self._parse_params()

codex/views/reader/{session.py → settings.py}

@@ -1,10 +1,12 @@
 """Reader session view."""
 
 from codex.serializers.reader import ReaderSettingsSerializer
-from codex.views.session import ReaderSessionViewBase, SessionViewBase
+from codex.views.settings import SettingsView
 
 
-class ReaderSessionView(ReaderSessionViewBase, SessionViewBase):
+class ReaderSettingsView(SettingsView):
     """Get Reader Settings."""
 
     serializer_class = ReaderSettingsSerializer  # type: ignore
+
+    SESSION_KEY = "reader"

codex/views/session.py

@@ -1,69 +1,23 @@
 """Manage user sessions with appropriate defaults."""
 
-from abc import ABC, abstractmethod
+from abc import ABC
 from copy import deepcopy
 from types import MappingProxyType
 
-from drf_spectacular.utils import extend_schema
-from rest_framework.generics import GenericAPIView
-from rest_framework.response import Response
-
 from codex.logger.logging import get_logger
 from codex.serializers.choices import DEFAULTS
-from codex.views.auth import IsAuthenticatedOrEnabledNonUsers
+from codex.views.auth import AuthFilterGenericAPIView
+from codex.views.util import pop_name
 
 LOG = get_logger(__name__)
 
 
-class SessionViewBaseBase(GenericAPIView, ABC):
+class SessionView(AuthFilterGenericAPIView, ABC):
     """Generic Session View."""
 
     # Must override both of these
-    @property
-    @classmethod
-    @abstractmethod
-    def SESSION_KEY(cls):  # noqa: N802, type: ignore
-        """Implement the session key string."""
-        raise NotImplementedError
-
-    SESSION_DEFAULTS = MappingProxyType({})
-
-    @classmethod
-    def _get_source_values_or_set_defaults(cls, defaults_dict, source_dict, data):
-        """Recursively copy source_dict values into data or use defaults."""
-        result = deepcopy(data)
-        for key, default_value in defaults_dict.items():
-            result[key] = source_dict.get(key, default_value)
-            if result[key] is None:
-                # extra check for migrated or corrupt data
-                result[key] = default_value
-            if isinstance(default_value, dict):
-                result[key] = cls._get_source_values_or_set_defaults(
-                    default_value, source_dict.get(key, {}), result[key]
-                )
-        return result
-
-    def get_from_session(self, key):  # only used by frontend
-        """Get one key from the session or its default."""
-        session = self.request.session.get(self.SESSION_KEY, self.SESSION_DEFAULTS)
-        return session.get(key, self.SESSION_DEFAULTS[key])
-
-    def save_params_to_session(self, params):  # reader session & browser final
-        """Save the session from params with defaults for missing values."""
-        try:
-            data = self._get_source_values_or_set_defaults(
-                self.SESSION_DEFAULTS, params, {}
-            )
-            self.request.session[self.SESSION_KEY] = data
-            self.request.session.save()
-        except Exception as exc:
-            LOG.warning(f"Saving params to session: {exc}")
+    SESSION_KEY = ""
 
-
-class BrowserSessionViewBase(SessionViewBaseBase):
-    """Browser session base."""
-
-    SESSION_KEY = "browser"  # type: ignore
     CONTRIBUTOR_PERSON_UI_FIELD = "contributors"
     STORY_ARC_UI_FIELD = "story_arcs"
     IDENTIFIER_TYPE_UI_FIELD = "identifier_type"
@@ -83,7 +37,6 @@ class BrowserSessionViewBase(SessionViewBaseBase):
             "locations": [],
             "monochrome": [],
             "original_format": [],
-            "q": "",
             "reading_direction": [],
             "series_groups": [],
             "stories": [],
@@ -95,63 +48,100 @@ class BrowserSessionViewBase(SessionViewBaseBase):
         }
     )
     FILTER_ATTRIBUTES = frozenset(_DYNAMIC_FILTER_DEFAULTS.keys())
+    BROWSER_SESSION_KEY = "browser"
+    READER_SESSION_KEY = "reader"
     SESSION_DEFAULTS = MappingProxyType(
         {
-            "filters": {
-                "bookmark": DEFAULTS["bookmarkFilter"],
-                **_DYNAMIC_FILTER_DEFAULTS,
+            BROWSER_SESSION_KEY: {
+                "breadcrumbs": DEFAULTS["breadcrumbs"],
+                "filters": {
+                    "bookmark": DEFAULTS["bookmarkFilter"],
+                    **_DYNAMIC_FILTER_DEFAULTS,
+                },
+                "order_by": DEFAULTS["orderBy"],
+                "order_reverse": DEFAULTS["orderReverse"],
+                "q": DEFAULTS["q"],
+                "search_results_limit": DEFAULTS["searchResultsLimit"],
+                "show": DEFAULTS["show"],
+                "dynamic_covers": DEFAULTS["dynamicCovers"],
+                "custom_covers": DEFAULTS["customCovers"],
+                "twenty_four_hour_time": DEFAULTS["twentyFourHourTime"],
+                "top_group": DEFAULTS["topGroup"],
+            },
+            READER_SESSION_KEY: {
+                "finish_on_last_page": DEFAULTS["finishOnLastPage"],
+                "fit_to": DEFAULTS["fitTo"],
+                "two_pages": DEFAULTS["twoPages"],
+                "read_rtl_in_reverse": DEFAULTS["readRtlInReverse"],
+                "reading_direction": DEFAULTS["readingDirection"],
             },
-            "order_by": DEFAULTS["orderBy"],
-            "order_reverse": False,
-            "q": DEFAULTS["q"],
-            "route": DEFAULTS["route"],
-            "show": DEFAULTS["show"],
-            "twenty_four_hour_time": False,
-            "top_group": DEFAULTS["topGroup"],
-        }
-    )
-
-
-class ReaderSessionViewBase(SessionViewBaseBase):
-    """Reader session base."""
-
-    SESSION_KEY = "reader"  # type: ignore
-    SESSION_DEFAULTS = MappingProxyType(
-        {
-            "fit_to": DEFAULTS["fitTo"],
-            "two_pages": False,
-            "reading_direction": DEFAULTS["readingDirection"],
         }
     )
 
+    def get_from_session(
+        self, key, default=None, session_key=None
+    ):  # only used by frontend
+        """Get one key from the session or its default."""
+        if session_key is None:
+            session_key = self.SESSION_KEY
+        session = self.request.session.get(
+            session_key, self.SESSION_DEFAULTS[session_key]
+        )
+        if default is None:
+            default = self.SESSION_DEFAULTS[session_key][key]
+        return session.get(key, default)
+
+    def get_last_route(self, name=True):
+        """Get the last route from the breadcrumbs."""
+        breadcrumbs = self.get_from_session(
+            "breadcrumbs", session_key=self.BROWSER_SESSION_KEY
+        )
+        if not breadcrumbs:
+            breadcrumbs = DEFAULTS["breadcrumbs"]
+        last_route = breadcrumbs[-1]
+        if not name:
+            last_route = pop_name(last_route)
 
-class SessionViewBase(SessionViewBaseBase, ABC):
-    """Session view for retrieving stored settings."""
-
-    permission_classes = (IsAuthenticatedOrEnabledNonUsers,)
+        return last_route
 
-    def load_params_from_session(self):
-        """Set the params from view session, creating missing values from defaults."""
-        session = self.request.session.get(self.SESSION_KEY, self.SESSION_DEFAULTS)
-        return self._get_source_values_or_set_defaults(
-            self.SESSION_DEFAULTS, session, {}
-        )
+    @classmethod
+    def _get_source_values_or_set_defaults(cls, defaults_dict, source_dict, data):
+        """Recursively copy source_dict values into data or use defaults."""
+        result = deepcopy(data)
+        for key, default_value in defaults_dict.items():
+            result[key] = source_dict.get(key, default_value)
+            if result[key] is None:
+                # extra check for migrated or corrupt data
+                result[key] = default_value
+            if isinstance(default_value, dict):
+                result[key] = cls._get_source_values_or_set_defaults(
+                    default_value, source_dict.get(key, {}), result[key]
+                )
+        return result
 
-    def get(self, *args, **kwargs):
-        """Get session settings."""
-        params = self.load_params_from_session()
-        data = {}
-        for key, filter_name in params.get("filters", {}).items():
-            if filter_name:
-                data[key] = filter_name
-        params["filters"] = data
-        serializer = self.get_serializer(params)
-        return Response(serializer.data)
+    def load_params_from_session(self, session_key=None, only=None):
+        """Get session settings with defaults."""
+        if not session_key:
+            session_key = self.SESSION_KEY
+        if only:
+            defaults = {}
+            for key in only:
+                if key:
+                    defaults[key] = self.SESSION_DEFAULTS[session_key][key]
+        else:
+            defaults = self.SESSION_DEFAULTS[session_key]
+
+        session = self.request.session.get(session_key, defaults)
+        return self._get_source_values_or_set_defaults(defaults, session, {})
 
-    @extend_schema(responses=None)
-    def put(self, *args, **kwargs):
-        """Update session settings."""
-        serializer = self.get_serializer(data=self.request.data)
-        serializer.is_valid(raise_exception=True)
-        self.save_params_to_session(serializer.validated_data)
-        return Response()
+    def save_params_to_session(self, params):  # reader session & browser final
+        """Save the session from params with defaults for missing values."""
+        try:
+            # Deepcopy this so serializing the values later later for http response doesn't alter them
+            params = deepcopy(dict(params))
+            defaults = self.SESSION_DEFAULTS[self.SESSION_KEY]
+            data = self._get_source_values_or_set_defaults(defaults, params, {})
+            self.request.session[self.SESSION_KEY] = data
+            self.request.session.save()
+        except Exception as exc:
+            LOG.warning(f"Saving params to session: {exc}")

codex/views/settings.py

@@ -0,0 +1,47 @@
+"""Settings View."""
+
+from abc import ABC
+
+from drf_spectacular.utils import extend_schema
+from rest_framework.response import Response
+
+from codex.serializers.settings import SettingsSerializer
+from codex.views.session import SessionView
+from codex.views.util import reparse_json_query_params
+
+_GET_JSON_PARAMS = frozenset({"only"})
+
+
+class SettingsView(SessionView, ABC):
+    """Settings View."""
+
+    input_serializer_class = SettingsSerializer
+
+    def validate_settings_get(self, _validated_data, params: dict) -> dict:
+        """Change bad settings."""
+        return params
+
+    @extend_schema(parameters=[SettingsSerializer])
+    def get(self, *args, **kwargs):
+        """Get session settings."""
+        data = self.request.GET
+        data = reparse_json_query_params(data, _GET_JSON_PARAMS)
+        serializer = self.input_serializer_class(data=data)
+        serializer.is_valid(raise_exception=True)
+        validated_data = serializer.validated_data
+        only = validated_data.get("only") if validated_data else None  # type: ignore
+        params = self.load_params_from_session(only=only)
+        params = self.validate_settings_get(validated_data, params)
+        serializer = self.get_serializer(params)
+        return Response(serializer.data)
+
+    @extend_schema(responses=None)
+    def patch(self, *args, **kwargs):
+        """Update session settings."""
+        data = self.request.data  # type: ignore
+        serializer = self.get_serializer(data=data)
+        serializer.is_valid(raise_exception=True)
+        params = self.load_params_from_session()
+        params.update(serializer.validated_data)
+        self.save_params_to_session(params)
+        return Response()

codex/views/template.py

@@ -13,7 +13,7 @@ class TemplateXMLRenderer(TemplateHTMLRenderer):
     format = "xml"
 
 
-class SimpleAPIView(APIView):
+class CodexAPIView(APIView):
     """APIView with a simple getter and no data."""
 
     content_type = "application/json"
@@ -26,14 +26,14 @@ class SimpleAPIView(APIView):
         )
 
 
-class CodexTemplateView(SimpleAPIView):
+class CodexTemplateView(CodexAPIView):
     """HTML Template View."""
 
     renderer_classes = (TemplateHTMLRenderer,)
     content_type = "text/html"
 
 
-class CodexXMLTemplateView(SimpleAPIView):
+class CodexXMLTemplateView(CodexAPIView):
     """XML Template View."""
 
     renderer_classes = (TemplateXMLRenderer,)