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

codex/views/browser/breadcrumbs.py

@@ -18,10 +18,10 @@ class BrowserBreadcrumbsView(BrowserPaginateView):
         """Load breadcrumbs and determine if they should be searched for a graft."""
         breadcrumbs: list[Route] = list(self.params.get("breadcrumbs", []))
         old_breadcrumbs = [Route(**crumb) for crumb in breadcrumbs]
-        changed = bool(old_breadcrumbs) and old_breadcrumbs[-1].group in valid_groups
-        if changed:
+        invalid = not old_breadcrumbs or old_breadcrumbs[-1].group not in valid_groups
+        if invalid:
             old_breadcrumbs = []
-        return old_breadcrumbs, changed
+        return old_breadcrumbs, invalid
 
     def _breadcrumbs_save(self, breadcrumbs):
         """Save the breadcrumbs to params."""
@@ -184,7 +184,7 @@ class BrowserBreadcrumbsView(BrowserPaginateView):
 
         return tuple(new_breadcrumbs), changed
 
-    def get_parent_breadcrumbs(
+    def get_breadcrumbs(
         self,
     ) -> tuple[Route, ...]:
         """Graft or create breadcrumbs by browser mode."""
@@ -199,4 +199,4 @@ class BrowserBreadcrumbsView(BrowserPaginateView):
         if changed:
             self._breadcrumbs_save(breadcrumbs)
 
-        return breadcrumbs[:-1] if breadcrumbs else ()
+        return breadcrumbs

codex/views/browser/browser.py

@@ -16,13 +16,9 @@ from codex.models import (
     Folder,
     Imprint,
     Library,
-    Publisher,
-    Series,
-    StoryArc,
     Volume,
 )
 from codex.serializers.browser.page import BrowserPageSerializer
-from codex.util import max_none
 from codex.views.browser.title import BrowserTitleView
 from codex.views.const import (
     COMIC_GROUP,
@@ -35,6 +31,15 @@ if TYPE_CHECKING:
 
 
 LOG = get_logger(__name__)
+_GROUP_INSTANCE_SELECT_RELATED: MappingProxyType[
+    type[BrowserGroupModel], tuple[str | None, ...]
+] = MappingProxyType(
+    {
+        Comic: ("series", "volume"),
+        Volume: ("series",),
+        Imprint: ("publisher",),
+    }
+)
 
 
 class BrowserView(BrowserTitleView):
@@ -49,19 +54,6 @@ class BrowserView(BrowserTitleView):
         }
     )
     TARGET = "browser"
-    _GROUP_INSTANCE_SELECT_RELATED: MappingProxyType[
-        type[BrowserGroupModel], tuple[str | None, ...]
-    ] = MappingProxyType(
-        {
-            Comic: ("series", "volume"),
-            Volume: ("series",),
-            Series: (None,),
-            Imprint: ("publisher",),
-            Publisher: (None,),
-            Folder: ("parent_folder",),
-            StoryArc: (None,),
-        }
-    )
 
     def __init__(self, *args, **kwargs):
         """Set params for the type checker."""
@@ -76,7 +68,7 @@ class BrowserView(BrowserTitleView):
         if pks and self.group_class:
             try:
                 select_related: tuple[str | None, ...] = (
-                    self._GROUP_INSTANCE_SELECT_RELATED[self.group_class]
+                    _GROUP_INSTANCE_SELECT_RELATED.get(self.group_class, (None,))
                 )
                 self.group_query = self.group_class.objects.select_related(
                     *select_related
@@ -157,16 +149,13 @@ class BrowserView(BrowserTitleView):
             count = 0
         return qs, count
 
-    def _get_page_mtime(self, group_qs):
-        if self.group_instance:
-            page_updated_at_max = self.group_instance.updated_at
-        else:
-            page_updated_at_max = group_qs.aggregate(max=Max("updated_at"))["max"]
-
-        agg_func = self.get_bookmark_updated_at_aggregate(self.model, True)
-        page_bookmark_updated_at = group_qs.aggregate(max=agg_func)["max"]
+    def _get_page_mtime(self):
+        if not self.is_bookmark_filtered and self.group_instance:
+            # Nice optimization if we can get get it.
+            return self.group_instance.updated_at
 
-        return max_none(page_updated_at_max, page_bookmark_updated_at)
+        group_model = self.group_class if self.group_class else self.model
+        return self.get_group_mtime(group_model, page_mtime=True)
 
     @staticmethod
     def _get_zero_pad(book_qs):
@@ -182,7 +171,6 @@ class BrowserView(BrowserTitleView):
     def _get_group_and_books(self):
         """Create the main queries with filters, annotation and pagination."""
         group_qs, group_count = self._get_group_queryset()
-        mtime = self._get_page_mtime(group_qs)
         book_qs, book_count = self._get_book_queryset()
         # Paginate
         group_qs, book_qs, num_pages, page_group_count, page_book_count = self.paginate(
@@ -200,6 +188,7 @@ class BrowserView(BrowserTitleView):
         # print(group_qs.query)
 
         total_count = page_group_count + page_book_count
+        mtime = self._get_page_mtime()
         return group_qs, book_qs, num_pages, total_count, zero_pad, mtime
 
     def get_object(self):
@@ -209,7 +198,7 @@ class BrowserView(BrowserTitleView):
         )
 
         # get additional context
-        parent_breadcrumbs = self.get_parent_breadcrumbs()
+        breadcrumbs = self.get_breadcrumbs()
         title = self.get_browser_page_title()
         # needs to happen after pagination
         # runs obj list query twice :/
@@ -218,7 +207,7 @@ class BrowserView(BrowserTitleView):
         # construct final data structure
         return MappingProxyType(
             {
-                "breadcrumbs": parent_breadcrumbs,
+                "breadcrumbs": breadcrumbs,
                 "title": title,
                 "model_group": self.model_group,
                 "groups": group_qs,
@@ -232,11 +221,10 @@ class BrowserView(BrowserTitleView):
             }
         )
 
-    @extend_schema(request=BrowserTitleView.input_serializer_class)
+    @extend_schema(parameters=[BrowserTitleView.input_serializer_class])
     def get(self, *_args, **_kwargs):
         """Get browser settings."""
         self.init_request()
         data = self.get_object()
         serializer = self.get_serializer(data)
-        self.save_params_to_session(self.params)
         return Response(serializer.data)

codex/views/browser/choices.py

@@ -15,11 +15,13 @@ from codex.models import (
     StoryArc,
 )
 from codex.models.named import IdentifierType
-from codex.serializers.browser.choices import CHOICES_SERIALIZER_CLASS_MAP
+from codex.serializers.browser.choices import (
+    BrowserChoicesFilterSerializer,
+)
 from codex.serializers.browser.filters import (
     BrowserFilterChoicesSerializer,
-    CharListField,
 )
+from codex.serializers.browser.settings import BrowserFilterChoicesInputSerilalizer
 from codex.serializers.models.pycountry import PyCountrySerializer
 from codex.views.browser.filters.annotations import (
     BrowserAnnotationsFilterView,
@@ -56,9 +58,15 @@ _NULL_NAMED_ROW = MappingProxyType({"pk": -1, "name": "_none_"})
 class BrowserChoicesViewBase(BrowserAnnotationsFilterView):
     """Get choices for filter dialog."""
 
-    SERIALIZER_MANY = False
+    input_serializer_class = BrowserFilterChoicesInputSerilalizer
     TARGET = "choices"
 
+    def init_request(self):
+        """Initialieze request."""
+        self.parse_params()
+        self.set_model()
+        self.set_rel_prefix()
+
     @staticmethod
     def get_field_choices_query(comic_qs, field_name):
         """Get distinct values for the field."""
@@ -97,12 +105,12 @@ class BrowserChoicesViewBase(BrowserAnnotationsFilterView):
         """Get the comic subquery use for the choices."""
         return self.get_filtered_queryset(Comic)
 
-    @extend_schema(request=BrowserAnnotationsFilterView.input_serializer_class)
+    @extend_schema(parameters=[input_serializer_class])
     def get(self, *_args, **_kwargs):
         """Return choices."""
         self.init_request()
         obj = self.get_object()
-        serializer = self.get_serializer(obj, many=self.SERIALIZER_MANY)
+        serializer = self.get_serializer(obj)
         return Response(serializer.data)
 
 
@@ -160,10 +168,7 @@ class BrowserChoicesAvailableView(BrowserChoicesViewBase):
 class BrowserChoicesView(BrowserChoicesViewBase):
     """Get choices for filter dialog."""
 
-    # serializer_class = Dynamic class determined in get()
-    SERIALIZER_MANY = True
-    # HACK get_serializer(data, many=True) requires this to be set for the debug API view
-    queryset = Comic.objects.none()
+    serializer_class = BrowserChoicesFilterSerializer
 
     def _get_field_choices(self, comic_qs, field_name):
         """Create a pk:name object for fields without tables."""
@@ -202,11 +207,6 @@ class BrowserChoicesView(BrowserChoicesViewBase):
         field_name = self.kwargs.get("field_name", "")
         return snakecase(field_name)
 
-    def get_serializer_class(self):  # type: ignore
-        """Dynamic serializer class."""
-        field_name = self._get_field_name()
-        return CHOICES_SERIALIZER_CLASS_MAP.get(field_name, CharListField)
-
     def get_object(self):
         """Return choices with more than one choice."""
         qs = super().get_object()
@@ -217,4 +217,7 @@ class BrowserChoicesView(BrowserChoicesViewBase):
             choices = self._get_m2m_field_choices(m2m_model, qs, rel)
         else:
             choices = self._get_field_choices(qs, rel)
-        return choices
+        return {
+            "field_name": field_name,
+            "choices": choices,
+        }

codex/views/browser/cover.py

@@ -9,12 +9,12 @@ from codex.librarian.covers.create import CoverCreateMixin
 from codex.librarian.covers.path import CoverPathMixin
 from codex.librarian.mp_queue import LIBRARIAN_QUEUE
 from codex.logger.logging import get_logger
-from codex.models import Comic, Folder, Volume
+from codex.models import Comic, Volume
 from codex.models.paths import CustomCover
-from codex.serializers.choices import DEFAULTS
+from codex.serializers.browser.settings import BrowserCoverInputSerializer
 from codex.views.browser.annotations import BrowserAnnotationsView
 from codex.views.const import (
-    GROUP_RELATION,
+    CUSTOM_COVER_GROUP_RELATION,
     MISSING_COVER_FN,
     MISSING_COVER_NAME_MAP,
     STATIC_IMG_PATH,
@@ -39,6 +39,7 @@ class WEBPRenderer(BaseRenderer):
 class CoverView(BrowserAnnotationsView):
     """ComicCover View."""
 
+    input_serializer_class = BrowserCoverInputSerializer
     renderer_classes = (WEBPRenderer,)
     content_type = "image/webp"
     TARGET = "cover"
@@ -56,39 +57,21 @@ class CoverView(BrowserAnnotationsView):
         pks = self.kwargs["pks"]
         return pks[0], False
 
-    def _use_dynamic_cover(self):
-        if not self.params.get("dynamic_covers"):
-            return False
-        filters = self.params.get("filters", {})
-        for key, value in filters.items():
-            if key == "bookmark" and value != DEFAULTS["bookmarkFilter"]:
-                return True
-            if value:
-                return True
-
-        order_by = self.params.get("order_by")
-        default_order_by = "filename" if self.model == Folder else "sort_name"
-        if order_by != default_order_by:
-            return True
-
-        if self.params.get("order_reverse"):
-            return True
-
-        return False
+    def _get_custom_cover(self):
+        """Get Custom Cover."""
+        if self.model == Volume or not self.params.get("custom_covers"):
+            return None
+        group = self.kwargs["group"]
+        group_rel = CUSTOM_COVER_GROUP_RELATION[group]
+        pks = self.kwargs["pks"]
+        comic_filter = {f"{group_rel}__in": pks}
+        qs = CustomCover.objects.filter(**comic_filter)
+        qs = qs.only("pk")
+        return qs.first()
 
     def _get_dynamic_cover(self):
         """Get dynamic cover."""
         self.set_order_key()
-        pks = self.kwargs["pks"]
-
-        if self.model != Volume and self.params.get("custom_covers"):
-            group = self.kwargs["group"]
-            group_rel = "folder" if self.model == Folder else GROUP_RELATION[group]  # type: ignore
-            comic_filter = {f"{group_rel}__in": pks}
-            custom_cover = CustomCover.objects.filter(**comic_filter).only("pk").first()
-            if custom_cover:
-                return custom_cover.pk, True
-
         comic_qs = self.get_filtered_queryset(Comic)
         comic_qs = self.annotate_order_aggregates(comic_qs, Comic)
         comic_qs = self.add_order_by(comic_qs, Comic)
@@ -99,40 +82,15 @@ class CoverView(BrowserAnnotationsView):
         cover_pk = comic.pk if comic else 0
         return cover_pk, False
 
-    def _get_first_cover(self):
-        """Get first cover."""
-        pks = self.kwargs["pks"]
-        order_by = (
-            "path"
-            if self.model == Folder
-            else "name"
-            if self.model == Volume
-            else "sort_name"
-        )
-        group_qs = self.model.objects.filter(pk__in=pks)  # type: ignore
-        group_qs = group_qs.order_by(order_by)
-        select_related = ["first_comic"]
-        custom_covers = self.params.get("custom_covers")
-        if custom_covers and self.model != Volume:
-            select_related.append("custom_cover")
-        group_qs = group_qs.select_related(*select_related)
-        group_qs = group_qs.group_by("id")  # type: ignore
-        group_obj = group_qs.first()
-        if custom_covers and self.model != Volume and group_obj.custom_cover:
-            return group_obj.custom_cover.pk, True
-        cover_pk = (
-            group_obj.first_comic.pk if group_obj and group_obj.first_comic else 0
-        )
-        return cover_pk, False
-
     def _get_cover_pk(self) -> tuple[int, bool]:
         """Get Cover Pk queryset for comic queryset."""
         if self.model == Comic:
             cover_pk, custom = self._get_comic_cover()
-        elif self._use_dynamic_cover():
-            cover_pk, custom = self._get_dynamic_cover()
+        elif custom_cover := self._get_custom_cover():
+            cover_pk = custom_cover.pk
+            custom = True
         else:
-            cover_pk, custom = self._get_first_cover()
+            cover_pk, custom = self._get_dynamic_cover()
         return cover_pk, custom
 
     def _get_missing_cover_path(self):
@@ -168,10 +126,16 @@ class CoverView(BrowserAnnotationsView):
                 thumb_image_data = f.read()
         return thumb_image_data, content_type
 
-    @extend_schema(responses={(200, content_type): OpenApiTypes.BINARY})
+    @extend_schema(
+        parameters=[BrowserAnnotationsView.input_serializer_class],
+        responses={(200, content_type): OpenApiTypes.BINARY},
+    )
     def get(self, *args, **kwargs):  # type: ignore
         """Get comic cover."""
-        self.init_request()
-        pk, custom = self._get_cover_pk()
-        thumb_image_data, content_type = self._get_cover_data(pk, custom)
-        return HttpResponse(thumb_image_data, content_type=content_type)
+        try:
+            self.init_request()
+            pk, custom = self._get_cover_pk()
+            thumb_image_data, content_type = self._get_cover_data(pk, custom)
+            return HttpResponse(thumb_image_data, content_type=content_type)
+        except Exception:
+            LOG.exception("get")

codex/views/browser/filters/annotations.py

@@ -1,35 +1,87 @@
 """Annotations used by a filter."""
 
-from django.db.models.aggregates import Count
+from django.db.models.aggregates import Count, Max
+from django.db.models.functions import Coalesce, Greatest
 
 from codex.models.comic import Comic
 from codex.views.browser.filters.bookmark import BookmarkFilterMixin
 from codex.views.browser.validate import BrowserValidateView
+from codex.views.const import (
+    EPOCH_START_DATETIMEFILED,
+    ONE_INTEGERFIELD,
+)
 
 
 class BrowserAnnotationsFilterView(BrowserValidateView, BookmarkFilterMixin):
     """Annotations that also filter."""
 
-    def get_query_filters(self, model):
+    def __init__(self, *args, **kwargs) -> None:
+        """Initialize."""
+        super().__init__(*args, **kwargs)
+        self.init_bookmark_data()
+
+    def _get_query_filters(self, model, group, pks, bookmark_filter, page_mtime=False):  # noqa: PLR0913
         """Return all the filters except the group filter."""
         object_filter = self.get_group_acl_filter(model)
-        object_filter &= self.get_bookmark_filter(model)
+        object_filter &= self.get_group_filter(group, pks, page_mtime=page_mtime)
         object_filter &= self.get_comic_field_filter(model)
-        object_filter &= self.get_group_filter(model)
+        if bookmark_filter:
+            # not needed because OuterRef is applied next
+            object_filter &= self.get_bookmark_filter(model)
         return object_filter
 
     def _filter_by_child_count(self, qs, model):
-        if model == Comic:
-            return qs
-
+        """Filter group by child count."""
         rel = self.rel_prefix + "pk"
-        qs = qs.alias(pre_search_child_count=Count(rel, distinct=True))
-        return qs.filter(pre_search_child_count__gt=0)
+        ann_name = "child_count"
+        count_func = ONE_INTEGERFIELD if model == Comic else Count(rel, distinct=True)
+        ann = {ann_name: count_func}
+        if self.TARGET == "opds2":
+            if model != Comic:
+                qs = qs.alias(**ann)
+        else:
+            qs = qs.annotate(**ann)
+        if model != Comic:
+            qs = qs.filter(**{f"{ann_name}__gt": 0})
+        return qs
 
-    def get_filtered_queryset(self, model):
+    def get_filtered_queryset(  # noqa: PLR0913
+        self, model, group=None, pks=None, bookmark_filter=True, page_mtime=False
+    ):
         """Get a filtered queryset for the model."""
-        object_filter = self.get_query_filters(model)
-
+        object_filter = self._get_query_filters(
+            model, group, pks, bookmark_filter, page_mtime=page_mtime
+        )
         qs = model.objects.filter(object_filter)
-        qs = self._filter_by_child_count(qs, model)
-        return self.apply_search_filter(qs, model)
+        qs = self.apply_search_filter(qs, model)
+        return self._filter_by_child_count(qs, model)
+
+    def get_group_mtime(self, model, group=None, pks=None, page_mtime=False):
+        """Get a filtered mtime for browser pages and mtime checker."""
+        qs = self.get_filtered_queryset(
+            model,
+            group=group,
+            pks=pks,
+            bookmark_filter=self.is_bookmark_filtered,
+            page_mtime=page_mtime,
+        )
+        qs = qs.annotate(max_updated_at=Max("updated_at"))
+
+        if self.is_bookmark_filtered:
+            bm_rel, bm_filter = self.get_bookmark_rel_and_filter(model)
+            qs = qs.filter(bm_filter)
+            ua_rel = bm_rel + "__updated_at"
+            mbua = Max(ua_rel)
+        else:
+            mbua = EPOCH_START_DATETIMEFILED
+        qs = qs.annotate(max_bookmark_updated_at=mbua)
+
+        mtime = qs.aggregate(
+            max=Greatest(
+                Coalesce("max_bookmark_updated_at", EPOCH_START_DATETIMEFILED),
+                "max_updated_at",
+            )
+        )["max"]
+        if mtime == NotImplemented:
+            mtime = None
+        return mtime

codex/views/browser/filters/bookmark.py

@@ -1,17 +1,26 @@
 """Bookmark filter view methods."""
 
+from typing import TYPE_CHECKING
+
 from django.db.models import Q
 
+if TYPE_CHECKING:
+    from codex.models import BrowserGroupModel
+
 
 class BookmarkFilterMixin:
     """BookmarkFilter view methods."""
 
-    def get_bm_rel(self, model):
+    def init_bookmark_data(self):
+        """Initialize the bm_annotation_data."""
+        self._bm_annotation_data: dict[BrowserGroupModel, tuple[str, Q]] = {}
+
+    def _get_bm_rel(self, model):
         """Create bookmark relation."""
         rel_prefix = self.get_rel_prefix(model)  # type: ignore
         return rel_prefix + "bookmark"
 
-    def get_my_bookmark_filter(self, bm_rel):
+    def _get_my_bookmark_filter(self, bm_rel):
         """Get a filter for my session or user defined bookmarks."""
         if self.request.user.is_authenticated:  # type: ignore
             my_bookmarks_kwargs = {f"{bm_rel}__user": self.request.user}  # type: ignore
@@ -22,12 +31,19 @@ class BookmarkFilterMixin:
             }
         return Q(**my_bookmarks_kwargs)
 
+    def get_bookmark_rel_and_filter(self, model):
+        """Get the bookmark rel and filter once."""
+        if model not in self._bm_annotation_data:
+            bm_rel = self._get_bm_rel(model)
+            bm_filter = self._get_my_bookmark_filter(bm_rel)
+            self._bm_annotation_data[model] = (bm_rel, bm_filter)
+        return self._bm_annotation_data[model]
+
     def get_bookmark_filter(self, model):
         """Build bookmark query."""
-        choice = self.params["filters"].get("bookmark", "")  # type: ignore
+        choice: str = self.params.get("filters", {}).get("bookmark", "")  # type: ignore
         if choice:
-            bm_rel = self.get_bm_rel(model)
-            my_bookmark_filter = self.get_my_bookmark_filter(bm_rel)
+            bm_rel, my_bookmark_filter = self.get_bookmark_rel_and_filter(model)
             if choice == "READ":
                 bookmark_filter = my_bookmark_filter & Q(
                     **{f"{bm_rel}__finished": True}

codex/views/browser/filters/group.py

@@ -2,8 +2,11 @@
 
 from django.db.models import Q
 
-from codex.models import Comic
-from codex.views.const import FOLDER_GROUP, GROUP_MODEL_MAP, GROUP_RELATION
+from codex.views.const import (
+    FILTER_ONLY_GROUP_RELATION,
+    FOLDER_GROUP,
+    GROUP_RELATION,
+)
 from codex.views.session import SessionView
 
 
@@ -12,22 +15,31 @@ class GroupFilterView(SessionView):
 
     SESSION_KEY = SessionView.BROWSER_SESSION_KEY
 
-    def get_group_filter(self, model):
+    def _get_rel_for_pks(self, group, page_mtime=False):
+        """Get the relation from the model to the pks."""
+        # XXX these TARGET refs might be better as subclass get rel methods.
+        target: str = self.TARGET  # type: ignore
+        if target in ("metadata", "mtime") or page_mtime:
+            # metadata, mtime, browser.page_mtime
+            rel = "pk"
+        elif target in ("choices", "cover"):
+            rel = FILTER_ONLY_GROUP_RELATION[group]
+        else:
+            rel = GROUP_RELATION[group]
+
+        rel += "__in"
+        return rel
+
+    def get_group_filter(self, group=None, pks=None, page_mtime=False):
         """Get filter for the displayed group."""
-        group = self.kwargs["group"]  # type: ignore
-        pks = self.kwargs["pks"]  # type: ignore
-        if pks:  # type: ignore
-            if model == GROUP_MODEL_MAP.get(group):
-                # metadata only
-                rel = "pk"
-            elif model == Comic and group == FOLDER_GROUP:
-                # choices & covers
-                rel = "folders"
-            else:
-                rel = GROUP_RELATION[group]
-
-            rel += "__in"
-            group_filter_dict = {rel: pks}  # type: ignore
+        if group is None:
+            group = self.kwargs["group"]
+        if pks is None:
+            pks = self.kwargs["pks"]
+
+        if pks and 0 not in pks:
+            rel = self._get_rel_for_pks(group, page_mtime)
+            group_filter_dict = {rel: pks}
         elif group == FOLDER_GROUP:
             group_filter_dict = {"parent_folder": None}
         else:

codex/views/browser/filters/search.py

@@ -135,11 +135,10 @@ class SearchFilterView(ComicFieldFilterView):
             if comic_ids:
                 # Prefilter comic ids. If nothing is allowed, don't search.
                 sqs = sqs.filter_comic_ids(comic_ids)
-                binary = (
+                if (
                     self.TARGET in frozenset({"cover", "choices"})
-                    or self.params.get("order_by", "") != "search_score"
-                )
-                if binary:
+                    or self.params.get("order_by", "") != "search_score"  # type: ignore
+                ):
                     scored_pks = self._get_binary_search_scores(sqs)
                 else:
                     score_pairs, prev_pks, next_pks, scored_pks = (