codex 1.6.0a9__py3-none-any.whl → 1.6.0a10__py3-none-any.whl

codex/views/opds/v1/feed.py

@@ -11,10 +11,10 @@ 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.const import FALSY, MAX_OBJ_PER_PAGE
 from codex.views.opds.auth import OPDSTemplateView
 from codex.views.opds.const import BLANK_TITLE, MimeType
@@ -56,6 +56,7 @@ class OPDS1FeedView(OPDS1LinksView, OPDSTemplateView):
 
     template_name = "opds_v1/index.xml"
     serializer_class = OPDS1TemplateSerializer
+    input_serializer_class = OPDSSettingsSerializer
     throttle_classes = (ScopedRateThrottle,)
     throttle_scope = "opds"
     TARGET = "opds1"
@@ -254,10 +255,7 @@ class OPDS1FeedView(OPDS1LinksView, OPDSTemplateView):
         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],
-    )
+    @extend_schema(parameters=[input_serializer_class])
     def get(self, *_args, **_kwargs):
         """Get the feed."""
         self.init_request()

codex/views/opds/v2/feed.py

@@ -7,8 +7,8 @@ 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.const import FALSY, MAX_OBJ_PER_PAGE
 from codex.views.opds.auth import OPDSAuthMixin
 from codex.views.opds.const import BLANK_TITLE
@@ -36,6 +36,7 @@ class OPDS2FeedView(OPDSAuthMixin, OPDS2PublicationView):
     throttle_scope = "opds"
 
     serializer_class = OPDS2FeedSerializer
+    input_serializer_class = OPDSSettingsSerializer
 
     def _title(self, browser_title):
         """Create the feed title."""
@@ -233,8 +234,7 @@ class OPDS2FeedView(OPDSAuthMixin, OPDS2PublicationView):
         # 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."""

codex/views/reader/arcs.py

@@ -4,7 +4,7 @@ from types import MappingProxyType
 
 from codex.models import AdminFlag
 from codex.util import max_none
-from codex.views.const import FOLDER_GROUP
+from codex.views.const import FOLDER_GROUP, STORY_ARC_GROUP
 from codex.views.reader.books import ReaderBooksView
 
 
@@ -16,6 +16,22 @@ class ReaderArcsView(ReaderBooksView):
         super().__init__(*args, **kwargs)
         self.params: MappingProxyType = MappingProxyType({})
 
+    def _get_group_arc(self, book, attr):
+        """Create the volume arc."""
+        group = getattr(book, attr, None)
+        if not group:
+            return None
+
+        _, arc_pks = self.get_group_pks_from_breadcrumbs([group])
+        if group.pk not in arc_pks:
+            arc_pks = (group.pk,)
+        return {
+            "group": attr[0],
+            "pks": arc_pks,
+            "name": group.name,
+            "mtime": group.updated_at,
+        }
+
     def _get_folder_arc(self, book):
         """Create the folder arc."""
         efv_flag = (
@@ -23,39 +39,16 @@ class ReaderArcsView(ReaderBooksView):
             .get(key=AdminFlag.FlagChoices.FOLDER_VIEW.value)
             .on
         )
+        if not efv_flag:
+            return None
 
-        if efv_flag:
-            folder = book.parent_folder
-            folder_arc = {
-                "group": FOLDER_GROUP,
-                "pks": (folder.pk,),
-                "name": folder.name,
-                "mtime": folder.updated_at,
-            }
-        else:
-            folder_arc = None
-        return folder_arc
-
-    def _get_series_arc(self, book):
-        """Create the series arc."""
-        series = book.series
-        if series:
-            arc_pks = self.get_series_pks_from_breadcrumbs()
-            if book.series.pk not in arc_pks:
-                arc_pks = (book.series.pk,)
-            arc = (
-                {
-                    "group": "s",
-                    "pks": arc_pks,
-                    "name": series.name,
-                    "mtime": series.updated_at,
-                }
-                if series
-                else None
-            )
-        else:
-            arc = None
-        return arc
+        folder = book.parent_folder
+        return {
+            "group": FOLDER_GROUP,
+            "pks": (folder.pk,),
+            "name": folder.name,
+            "mtime": folder.updated_at,
+        }
 
     def _get_story_arcs(self, book):
         """Create story arcs."""
@@ -74,26 +67,24 @@ class ReaderArcsView(ReaderBooksView):
     def get_arcs(self, book):
         """Get all series/folder/story arcs."""
         # create top arcs
-        folder_arc = self._get_folder_arc(book)
-        series_arc = self._get_series_arc(book)
-
-        # order top arcs
+        arcs = []
         top_group = self.params.get("top_group")
-        if top_group == FOLDER_GROUP and folder_arc:
-            arc = folder_arc
-            other_arc = series_arc
-        else:
+        arc = None
+        if series_arc := self._get_group_arc(book, "series"):
+            arcs.append(series_arc)
             arc = series_arc
-            other_arc = folder_arc
-
-        arcs = []
-        arcs.append(arc)
-        if other_arc:
-            arcs.append(other_arc)
-
-        # story arcs
-        sas = self._get_story_arcs(book)
-        arcs += sas
+        if volume_arc := self._get_group_arc(book, "volume"):
+            arcs.append(volume_arc)
+            if not arc:
+                arc = volume_arc
+        if folder_arc := self._get_folder_arc(book):
+            arcs.append(folder_arc)
+            if top_group == FOLDER_GROUP:
+                arc = folder_arc
+        if story_arcs := self._get_story_arcs(book):
+            arcs = [*arcs, *story_arcs]
+            if top_group == STORY_ARC_GROUP:
+                arc = story_arcs[0]
 
         max_mtime = None
         for arc in arcs:

codex/views/reader/books.py

@@ -2,18 +2,17 @@
 
 from typing import TYPE_CHECKING
 
-from django.db.models import F, IntegerField, Value
+from django.db.models import F
 
 from codex.models import Bookmark, Comic
 from codex.views.bookmark import BookmarkBaseView
-from codex.views.const import FOLDER_GROUP
+from codex.views.const import FOLDER_GROUP, NONE_INTEGERFIELD
 from codex.views.mixins import SharedAnnotationsMixin
-from codex.views.session import SessionView
+from codex.views.reader.init import ReaderInitView
 
 if TYPE_CHECKING:
     from collections.abc import Mapping
 
-_MIN_CRUMB_WALKBACK_LEN = 3
 _SETTINGS_ATTRS = ("fit_to", "two_pages", "reading_direction")
 _COMIC_FIELDS = (
     "file_type",
@@ -25,60 +24,40 @@ _COMIC_FIELDS = (
     "reading_direction",
     "updated_at",
 )
-_SHOW = {
-    "series": True,
-    "volume": True,
-}
 
 
-class ReaderBooksView(BookmarkBaseView, SessionView, SharedAnnotationsMixin):
+class ReaderBooksView(BookmarkBaseView, ReaderInitView, SharedAnnotationsMixin):
     """Get Books methods."""
 
-    def get_series_pks_from_breadcrumbs(self):
-        """Get Multi-Group pks from the breadcrumbs."""
-        if self.series_pks:
-            return self.series_pks
-        breadcrumbs = self.get_from_session(
-            "breadcrumbs", session_key=self.BROWSER_SESSION_KEY
-        )
-        if breadcrumbs:
-            crumb = breadcrumbs[-1]
-            crumb_group = crumb.get("group")
-            if crumb_group == "v" and len(breadcrumbs) >= _MIN_CRUMB_WALKBACK_LEN:
-                crumb = breadcrumbs[-2]
-                crumb_group = crumb.get("group")
-            if crumb_group == "s":
-                self.series_pks = crumb.get("pks", ())
-
-        return self.series_pks
-
-    def _get_reader_arc_pks(
-        self, arc, arc_pk_select_related, prefetch_related, arc_pk_rel
+    def _get_reader_arc_pks(  # noqa: PLR0913
+        self, arc, arc_pk_select_related, prefetch_related, arc_pk_rel, arc_group
     ):
         """Get the nav filter."""
-        arc_pks = arc.get("pks", ())
+        if arc_pks := arc.get("pks", ()):
+            return arc_pks
+
+        comic_pk = self.kwargs["pk"]
+        try:
+            arc_pk_qs = Comic.objects.filter(pk=comic_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_qs = arc_pk_qs.values_list(arc_pk_rel, flat=True)
+            arc_pk = arc_pk_qs.first()
+        except IndexError:
+            arc_pk = 0
+
+        _, multi_arc_pks = self.get_group_pks_from_breadcrumbs([arc_group])
+        if not arc_pk or arc_pk in multi_arc_pks:
+            arc_pks = multi_arc_pks
+
         if not arc_pks:
-            comic_pk = self.kwargs["pk"]
-            try:
-                arc_pk_qs = Comic.objects.filter(pk=comic_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 = arc_pk_qs.values_list(arc_pk_rel, flat=True)[0]
-            except IndexError:
-                arc_pk = 0
-
-            if arc_pk_rel == "series__pk":
-                multi_arc_pks = self.get_series_pks_from_breadcrumbs()
-                if not arc_pk or arc_pk in multi_arc_pks:
-                    arc_pks = multi_arc_pks
-            if not arc_pks:
-                arc_pks = (arc_pk,)
+            arc_pks = (arc_pk,)
 
         return arc_pks
 
     def _get_comics_list(self):
         """Get the reader naviation group filter."""
-        select_related = ("series",)
+        select_related = ("series", "volume")
         prefetch_related = ()
 
         arc: Mapping = self.params.get("arc", {})  # type: ignore
@@ -91,31 +70,35 @@ class ReaderBooksView(BookmarkBaseView, SessionView, SharedAnnotationsMixin):
             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")
+            ordering = ("arc_index", "date", "pk")
             arc_pk_select_related = ()
         elif arc_group == FOLDER_GROUP:
             # folder mode
             rel = "parent_folder"
             fields = (*_COMIC_FIELDS, "parent_folder")
             arc_pk_rel = "parent_folder__pk"
-            select_related = (*select_related, "parent_folder")
-            arc_index = Value(None, IntegerField())
+            arc_index = NONE_INTEGERFIELD
             ordering = ("path", "pk")
             arc_pk_select_related = ("parent_folder",)
+        elif arc_group == "v":
+            # volume
+            rel = "volume"
+            fields = _COMIC_FIELDS
+            arc_pk_rel = "volume__pk"
+            arc_index = NONE_INTEGERFIELD
+            ordering = ()
+            arc_pk_select_related = ("volume",)
         else:
-            # browser mode.
+            # series
             rel = "series"
             fields = _COMIC_FIELDS
             arc_pk_rel = "series__pk"
-            arc_index = Value(None, IntegerField())
+            arc_index = NONE_INTEGERFIELD
             ordering = ()
             arc_pk_select_related = ("series",)
 
         arc_pks = self._get_reader_arc_pks(
-            arc,
-            arc_pk_select_related,
-            prefetch_related,
-            arc_pk_rel,
+            arc, arc_pk_select_related, prefetch_related, arc_pk_rel, arc_group
         )
         nav_filter = {f"{rel}__in": arc_pks}
         group_acl_filter = self.get_group_acl_filter(Comic)
@@ -136,9 +119,11 @@ class ReaderBooksView(BookmarkBaseView, SessionView, SharedAnnotationsMixin):
             .annotate(mtime=F("updated_at"))
         )
         qs = self.annotate_group_names(qs, Comic)
-        if arc_group == "s":
+        if arc_group in ("v", "s"):
+            show = self.params["show"]
+            model_group = "i" if arc_group == "s" else "s"
             qs, comic_sort_names = self.alias_sort_names(
-                qs, Comic, pks=arc_pks, model_group="i", show=_SHOW
+                qs, Comic, pks=arc_pks, model_group=model_group, show=show
             )
             ordering = (
                 *comic_sort_names,
@@ -146,7 +131,8 @@ class ReaderBooksView(BookmarkBaseView, SessionView, SharedAnnotationsMixin):
                 "issue_suffix",
                 "sort_name",
             )
-        return qs.order_by(*ordering), arc_group
+        qs = qs.order_by(*ordering)
+        return qs, arc_group
 
     def _append_with_settings(self, book, bookmark_filter):
         """Append bookmark to book list."""
@@ -183,9 +169,9 @@ class ReaderBooksView(BookmarkBaseView, SessionView, SharedAnnotationsMixin):
                         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.get_filename()  # type: ignore
+                if book.arc_index is None:
+                    book.arc_index = index + 1
+                book.filename = book.get_filename()
                 book.arc_group = arc_group
                 book.arc_count = comics.count()
                 books["current"] = self._append_with_settings(book, bookmark_filter)
@@ -193,5 +179,3 @@ class ReaderBooksView(BookmarkBaseView, SessionView, SharedAnnotationsMixin):
                 # Haven't matched yet, so set the previous comic
                 prev_book = book
         return books
-
-    #####

codex/views/reader/init.py

@@ -0,0 +1,121 @@
+"""Views for reading comic books."""
+
+from copy import deepcopy
+from types import MappingProxyType
+
+from codex.logger.logging import get_logger
+from codex.models import Comic
+from codex.serializers.reader import (
+    ReaderViewInputSerializer,
+)
+from codex.views.const import FOLDER_GROUP, GROUP_RELATION, STORY_ARC_GROUP
+from codex.views.session import SessionView
+from codex.views.util import reparse_json_query_params
+
+LOG = get_logger(__name__)
+VALID_ARC_GROUPS = frozenset({"s", "v", "f", "a"})
+_JSON_KEYS = frozenset({"arc", "breadcrumbs", "show"})
+_BROWSER_SESSION_DEFAULTS = SessionView.SESSION_DEFAULTS[
+    SessionView.BROWSER_SESSION_KEY
+]
+_DEFAULT_PARAMS = {
+    "breadcrumbs": _BROWSER_SESSION_DEFAULTS["breadcrumbs"],
+    "show": _BROWSER_SESSION_DEFAULTS["show"],
+    "top_group": _BROWSER_SESSION_DEFAULTS["top_group"],
+}
+
+
+class ReaderInitView(SessionView):
+    """Reader initialization."""
+
+    input_serializer_class = ReaderViewInputSerializer
+
+    def __init__(self, *args, **kwargs):
+        """Initialize instance vars."""
+        super().__init__(*args, **kwargs)
+        self.group_pks: dict[str, tuple[int, ...]] = {}
+
+    def _set_group_pks_from_breadcrumbs(self, groups, breadcrumbs):
+        """Set Multi-Group pks from breadcrumbs to the cache."""
+        index = len(breadcrumbs) - 1
+        min_index = max(index - 1, 0) if FOLDER_GROUP in groups else 0
+        while index > min_index:
+            crumb = breadcrumbs[index]
+            crumb_group = crumb.get("group")
+            if crumb_group in groups:
+                pks = crumb.get("pks", ())
+                self.group_pks[crumb_group] = pks
+                break
+            index -= 1
+        else:
+            crumb_group = ""
+            pks = ()
+            for group in groups:
+                self.group_pks[group] = pks
+        return crumb_group, pks
+
+    def get_group_pks_from_breadcrumbs(self, groups):
+        """Get Multi-Group pks from the breadcrumbs."""
+        # Return cached values
+        for group in groups:
+            if pks := self.group_pks.get(group):
+                return group, pks
+
+        # Validate input
+        breadcrumbs: tuple = self.params.get("breadcrumbs")  # type: ignore
+        if not breadcrumbs:
+            return "", ()
+
+        return self._set_group_pks_from_breadcrumbs(groups, breadcrumbs)
+
+    def _ensure_arc_contains_comic(self, params):
+        """Arc sanity check."""
+        arc = params.get("arc")
+        if not arc:
+            return
+        pk = self.kwargs["pk"]
+        arc_group = arc.get("group")
+        arc_pks = arc.get("pks")
+        valid = False
+        if rel := GROUP_RELATION.get(arc_group):
+            arc_filter = {rel: arc_pks}
+            valid = Comic.objects.filter(pk=pk, **arc_filter).exists()
+        if not valid:
+            LOG.warning(f"Invalid arc {arc} submitted to reader for comic {pk}.")
+            params.pop("arc", None)
+
+    def _ensure_arc(self, params):
+        """arc.group validation."""
+        # Can't be in the serializer
+        arc = params.get("arc", {})
+
+        if arc.get("group") not in VALID_ARC_GROUPS:
+            top_group = params["top_group"]
+            if top_group in (FOLDER_GROUP, STORY_ARC_GROUP):
+                search_groups = (top_group,)
+            else:
+                search_groups = ("v", "s")
+
+            group, pks = self.get_group_pks_from_breadcrumbs(search_groups)
+            if not group:
+                group = "s"
+
+            arc["group"] = group
+            if pks:
+                arc["pks"] = pks
+
+        params["arc"] = arc
+
+    def _parse_params(self):
+        data = self.request.GET
+        data = reparse_json_query_params(self.request.GET, _JSON_KEYS)
+        serializer = self.input_serializer_class(data=data)
+        serializer.is_valid(raise_exception=True)
+
+        params = deepcopy(_DEFAULT_PARAMS)
+        if serializer.validated_data:
+            params.update(serializer.validated_data)  # type: ignore
+        self._ensure_arc_contains_comic(params)
+        self._ensure_arc(params)
+
+        self.params = MappingProxyType(params)

codex/views/reader/reader.py

@@ -1,43 +1,30 @@
 """Views for reading comic books."""
 
-from types import MappingProxyType
-
 from comicbox.box import Comicbox
 from django.urls import reverse
-from drf_spectacular.types import OpenApiTypes
-from drf_spectacular.utils import OpenApiParameter, extend_schema
-from rest_framework.exceptions import NotFound, ValidationError
+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.serializers.reader import ReaderArcSerializer, ReaderComicsSerializer
+from codex.serializers.reader import ReaderComicsSerializer, ReaderViewInputSerializer
 from codex.serializers.redirect import ReaderRedirectSerializer
 from codex.views.reader.arcs import ReaderArcsView
-from codex.views.util import pop_name, reparse_json_query_params
+from codex.views.util import pop_name
 
 LOG = get_logger(__name__)
-_VALID_ARC_GROUPS = frozenset({"f", "s", "a"})
-_JSON_KEYS = frozenset({"arc"})
 
 
-class ReaderView(
-    ReaderArcsView,
-):
+class ReaderView(ReaderArcsView):
     """Get info for displaying comic pages."""
 
     serializer_class = ReaderComicsSerializer
-    input_serializer_class = ReaderArcSerializer
 
     SESSION_KEY = "reader"
     TARGET = "reader"
 
-    def __init__(self, *args, **kwargs):
-        """Initialize instance vars."""
-        super().__init__(*args, **kwargs)
-        self.series_pks: tuple[int, ...] = ()
-
     def _raise_not_found(self):
         """Raise not found exception."""
         pk = self.kwargs.get("pk")
@@ -48,48 +35,6 @@ class ReaderView(
         }
         raise NotFound(detail=detail)
 
-    def _validate_params(self, arc, top_group):
-        """arc.group validation."""
-        # Can't be in the serializer
-        arc_group = arc.get("group", "")
-        if not arc_group:
-            series_pks = self.get_series_pks_from_breadcrumbs()
-            if series_pks:
-                arc_group = "s"
-                arc["pks"] = series_pks
-        if not arc_group:
-            arc_group = top_group
-        if arc_group not in _VALID_ARC_GROUPS:
-            arc_group = None
-
-    def _parse_params(self):
-        data = self.request.GET
-        arc = {}
-        data = reparse_json_query_params(self.request.GET, _JSON_KEYS)
-        arc_data = data.get("arc", [])
-        if arc_data:
-            serializer = self.input_serializer_class(data=arc_data)
-            try:
-                serializer.is_valid()
-                arc: dict = serializer.validated_data  # type: ignore
-            except ValidationError:
-                pass
-
-        # From Browser Session
-        top_group = self.get_from_session(
-            "top_group", "s", session_key=self.BROWSER_SESSION_KEY
-        )
-
-        self._validate_params(arc, top_group)
-
-        params = MappingProxyType(
-            {
-                "arc": arc,
-                "top_group": top_group,
-            }
-        )
-        self.params = params
-
     @staticmethod
     def _lazy_metadata(current, prev_book, next_book):
         """Get reader metadata from comicbox if it's not in the db."""
@@ -117,7 +62,6 @@ class ReaderView(
     def get_object(self):
         """Get the previous and next comics in a group or story arc."""
         # Books
-        self.last_route = self.get_last_route()
         books = self.get_book_collection()
 
         current = books.get("current")
@@ -144,7 +88,9 @@ class ReaderView(
             arc["pks"] = (current.arc_pk,)  # type: ignore
         arc["index"] = current.arc_index  # type:ignore
         arc["count"] = current.arc_count  # type: ignore
-        close_route = pop_name(self.last_route)
+
+        close_route = self.get_last_route()
+        close_route = pop_name(close_route)
 
         return {
             "books": books,
@@ -154,14 +100,7 @@ class ReaderView(
             "mtime": mtime,
         }
 
-    @extend_schema(
-        parameters=[
-            OpenApiParameter(
-                "arc[group]", OpenApiTypes.STR, enum=sorted(_VALID_ARC_GROUPS)
-            ),
-            OpenApiParameter("arc[pks]", OpenApiTypes.STR),
-        ]
-    )
+    @extend_schema(parameters=[ReaderViewInputSerializer])
     def get(self, *args, **kwargs):
         """Get the book info."""
         self._parse_params()

codex/views/session.py

@@ -102,17 +102,6 @@ class SessionView(AuthFilterGenericAPIView, ABC):
 
         return last_route
 
-    def load_params_from_session(self, validated_data=None, session_key=None):
-        """Load params from the session with defaults."""
-        session_key = session_key if session_key else self.SESSION_KEY
-        params = deepcopy(dict(self.SESSION_DEFAULTS[session_key]))
-        session_params = self.request.session.get(session_key)
-        if session_params:
-            params.update(session_params)
-        if validated_data:
-            params.update(validated_data)
-        self.params = MappingProxyType(params)
-
     @classmethod
     def _get_source_values_or_set_defaults(cls, defaults_dict, source_dict, data):
         """Recursively copy source_dict values into data or use defaults."""
@@ -128,6 +117,21 @@ class SessionView(AuthFilterGenericAPIView, ABC):
                 )
         return result
 
+    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, {})
+
     def save_params_to_session(self, params):  # reader session & browser final
         """Save the session from params with defaults for missing values."""
         try: