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

codex/views/reader/books.py

@@ -1,20 +1,18 @@
 """Get Books methods."""
 
-from copy import deepcopy
 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",
@@ -28,54 +26,38 @@ _COMIC_FIELDS = (
 )
 
 
-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
@@ -88,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)
@@ -133,14 +119,11 @@ class ReaderBooksView(BookmarkBaseView, SessionView, SharedAnnotationsMixin):
             .annotate(mtime=F("updated_at"))
         )
         qs = self.annotate_group_names(qs, Comic)
-        if arc_group == "s":
-            show = deepcopy(
-                self.get_from_session("show", session_key=self.BROWSER_SESSION_KEY)
-            )
-            show.pop("p", None)
-            show.pop("i", None)
+        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,
@@ -148,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."""
@@ -169,7 +153,7 @@ class ReaderBooksView(BookmarkBaseView, SessionView, SharedAnnotationsMixin):
         Yields 1 to 3 books
         """
         comics, arc_group = self._get_comics_list()
-        bookmark_filter = self.get_bookmark_filter()
+        bookmark_filter = self.get_bookmark_search_kwargs()
         books = {}
         prev_book = None
         pk = self.kwargs.get("pk")
@@ -185,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)
@@ -195,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,42 +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
 
 LOG = get_logger(__name__)
-_VALID_ARC_GROUPS = frozenset({"f", "s", "a"})
 
 
-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")
@@ -47,46 +35,6 @@ class ReaderView(
         }
         raise NotFound(detail=detail)
 
-    def _parse_params(self):
-        data = self.request.GET
-        # Hack for query_parm parser
-        arc_data = MappingProxyType(
-            {"group": data.get("arc[group]"), "pks": data.get("arc[pks]")}
-        )
-        serializer = self.input_serializer_class(data=arc_data)
-        arc = {}
-        try:
-            serializer.is_valid()
-            arc: dict = serializer.validated_data  # type: ignore
-        except ValidationError:
-            pass
-
-        # PARAMS
-        top_group = self.get_from_session(
-            "top_group", "s", session_key=self.BROWSER_SESSION_KEY
-        )
-
-        # 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
-
-        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."""
@@ -114,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")
@@ -141,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,
@@ -151,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:

codex/views/settings.py

@@ -5,30 +5,43 @@ 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."""
-        defaults = self.SESSION_DEFAULTS[self.SESSION_KEY]
-        session = self.request.session.get(self.SESSION_KEY, defaults)
-        params = self._get_source_values_or_set_defaults(defaults, session, {})
-        data = {}
-        for key, filter_name in params.get("filters", {}).items():
-            if filter_name:
-                data[key] = filter_name
-        params["filters"] = data
+        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 put(self, *args, **kwargs):
+    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)
-        self.save_params_to_session(serializer.validated_data)
+        params = self.load_params_from_session()
+        params.update(serializer.validated_data)
+        self.save_params_to_session(params)
         return Response()

codex/views/util.py

@@ -26,6 +26,7 @@ class Route(dict):
             bool(cmp is not None)
             and (self.group == cmp.group)
             and (set(self.pks) == set(cmp.pks))
+            and (self.page == cmp.page)
         )
 
     def __and__(self, cmp):
@@ -33,7 +34,7 @@ class Route(dict):
         return (
             bool(cmp is not None)
             and (self.group == cmp.group)
-            and (set(self.pks) & set(cmp.pks))
+            and (self.pks == cmp.pks or (set(self.pks) & set(cmp.pks)))
         )
 
     dict = asdict

codex/websockets/consumers.py

@@ -14,24 +14,28 @@ LOG = get_logger(__name__)
 class NotifierConsumer(AsyncWebsocketConsumer):
     """Base Notifier Consumer."""
 
-    @staticmethod
-    def _get_groups(user):
+    def _get_groups(self):
         """Dynamic groups by user type."""
         groups = [ChannelGroups.ALL.name]
-        if user.is_staff:
+        user = self.scope.get("user") if self.scope else None
+        user_channel = None
+        if user:
+            user_channel = f"user_{user.id}"
+        else:
+            session = self.scope.get("session")
+            if session:
+                user_channel = f"user_{session.session_key}"
+        if user_channel:
+            groups += [user_channel]
+        if user and user.is_staff:
             groups += [ChannelGroups.ADMIN.name]
         return groups
 
     async def websocket_connect(self, message):
         """Authorize with user and connect websocket to groups."""
         # Authorization
-        user = self.scope.get("user") if self.scope else None
-        if not user:
-            LOG.warning("Websockets not available for unregistered users.")
-            return
-
         # Set groups for user.
-        self.groups = self._get_groups(user)
+        self.groups = self._get_groups()
 
         await super().websocket_connect(message)
         LOG.debug(f"Websocket connected to {self.groups}")

{codex-1.6.0a8.dist-info → codex-1.6.0a10.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: codex
-Version: 1.6.0a8
+Version: 1.6.0a10
 Summary: A comic archive web server.
 Home-page: https://github.com/ajslater/codex
 License: GPL-3.0-only