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

codex/views/browser/annotations.py

@@ -7,7 +7,6 @@ from django.db.models import (
     Avg,
     BooleanField,
     Case,
-    DateTimeField,
     F,
     FilteredRelation,
     Max,
@@ -17,16 +16,16 @@ from django.db.models import (
     Value,
     When,
 )
+from django.db.models.expressions import OuterRef
 from django.db.models.fields import CharField, PositiveSmallIntegerField
-from django.db.models.functions import Least, Reverse, Right, StrIndex
+from django.db.models.functions import Coalesce, Least, Reverse, Right, StrIndex
+from django.db.models.functions.comparison import Greatest
 
+from codex.logger.logging import get_logger
 from codex.models import (
     BrowserGroupModel,
     Comic,
     Folder,
-    Imprint,
-    Publisher,
-    Series,
     StoryArc,
     Volume,
 )
@@ -34,21 +33,14 @@ from codex.models.functions import JsonGroupArray
 from codex.views.browser.order_by import (
     BrowserOrderByView,
 )
-from codex.views.const import STORY_ARC_GROUP
+from codex.views.const import (
+    EPOCH_START,
+    NONE_DATETIMEFIELD,
+    NONE_INTEGERFIELD,
+    STORY_ARC_GROUP,
+)
 from codex.views.mixins import SharedAnnotationsMixin
 
-_REL_MAP = MappingProxyType(
-    {
-        Publisher: "publisher",
-        Imprint: "imprint",
-        Series: "series",
-        Volume: "volume",
-        Folder: "parent_folder",
-        StoryArc: "story_arc_numbers__story_arc",
-    }
-)
-_NONE_INTEGERFIELD = Value(None, PositiveSmallIntegerField())
-_NONE_DATETIMEFIELD = Value(None, DateTimeField())
 _ORDER_AGGREGATE_FUNCS = MappingProxyType(
     # These are annotated to order_value because they're simple relations
     {
@@ -76,6 +68,8 @@ _ALTERNATE_GROUP_BY: MappingProxyType[type[BrowserGroupModel], str] = MappingPro
     {Comic: "id", Volume: "name"}
 )
 
+LOG = get_logger(__name__)
+
 
 class BrowserAnnotationsView(BrowserOrderByView, SharedAnnotationsMixin):
     """Base class for views that need special metadata annotations."""
@@ -86,7 +80,6 @@ class BrowserAnnotationsView(BrowserOrderByView, SharedAnnotationsMixin):
         self.is_opds_1_acquisition = False
         self.comic_sort_names = ()
         self.bm_annotataion_data: dict[BrowserGroupModel, tuple[str, dict]] = {}
-        self.cover_search_score_pairs: tuple[tuple[int, float], ...] = ()
 
     def get_group_by(self, model=None):
         """Get the group by for the model."""
@@ -150,7 +143,7 @@ class BrowserAnnotationsView(BrowserOrderByView, SharedAnnotationsMixin):
             )
             story_arc_number = self.order_agg_func("selected_story_arc_number__number")
         else:
-            story_arc_number = _NONE_INTEGERFIELD
+            story_arc_number = NONE_INTEGERFIELD
 
         return qs.alias(story_arc_number=story_arc_number)
 
@@ -170,17 +163,11 @@ class BrowserAnnotationsView(BrowserOrderByView, SharedAnnotationsMixin):
 
     def get_bookmark_updated_at_aggregate(self, model, always_max=False):
         """Get The aggregate function for relevant bookmark.updated_at."""
-        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  # type: ignore
+        bm_rel, bm_filter = self.get_bookmark_rel_and_filter(model)
 
-        updated_at_rel = f"{bm_rel}__updated_at"
+        bm_updated_at_rel = f"{bm_rel}__updated_at"
         agg_func = Max if always_max else self.order_agg_func
-        return agg_func(
-            updated_at_rel,
-            default=_NONE_DATETIMEFIELD,
-            filter=bm_filter,
-        )
+        return agg_func(bm_updated_at_rel, default=NONE_DATETIMEFIELD, filter=bm_filter)
 
     def _annotate_bookmark_updated_at(self, qs, model):
         if (
@@ -231,54 +218,6 @@ class BrowserAnnotationsView(BrowserOrderByView, SharedAnnotationsMixin):
             qs = self._annotate_order_value(qs, model)
         return qs
 
-    def _annotate_cover_pk(self, qs, model):
-        """Annotate the query set for the coverpath for the sort."""
-        # Select comics for the children by an outer ref for annotation
-        # Order the descendant comics by the sort argumentst
-        cover_style = self.params.get("cover_style")
-        if model == Comic:
-            default_cover_pk = F("pk")
-            default_cover_mtime = F("updated_at")
-        elif cover_style == "i":
-            default_cover_pk = None
-            default_cover_mtime = None
-        elif cover_style == "f":
-            # At this point it's only been filtered.
-            default_cover_pk = F(self.rel_prefix + "pk")
-            default_cover_mtime = F(self.rel_prefix + "updated_at")
-        else:  # cover_style == "d"
-            default_cover_pk = F(self.rel_prefix + "pk")
-            if self.is_bookmark_filtered:
-                default_cover_mtime = Case(
-                    When(bookmark_updated_at__gt=F(self.rel_prefix + "updated_at")),
-                    then=F("bookmark_updated_at"),
-                    default=F(self.rel_prefix + "updated_at"),
-                )
-            else:
-                default_cover_mtime = F(self.rel_prefix + "updated_at")
-
-        if model in (Volume, Comic):
-            cover_custom = Value(False)
-            cover_pk = default_cover_pk
-            cover_mtime = default_cover_mtime
-        else:
-            cover_custom = F("custom_cover")
-            cover_pk = Case(
-                When(custom_cover__isnull=False, then=F("custom_cover__pk")),
-                default=default_cover_pk,
-            )
-            cover_mtime = Case(
-                When(custom_cover__isnull=False, then=F("custom_cover__updated_at")),
-                default=default_cover_mtime,
-            )
-
-        return qs.annotate(
-            cover_custom=cover_custom,
-            cover_pk=cover_pk,
-            cover_mtime=cover_mtime,
-            cover_pks=JsonGroupArray("cover_pk", distinct=True),
-        )
-
     def _annotate_group(self, qs, model):
         """Annotate Group."""
         value = "c" if model == Comic else self.model_group  # type: ignore
@@ -286,11 +225,7 @@ class BrowserAnnotationsView(BrowserOrderByView, SharedAnnotationsMixin):
 
     def _annotate_bookmarks(self, qs, model):
         """Hoist up bookmark annotations."""
-        if model in self.bm_annotation_data:  # type: ignore
-            bm_rel, bm_filter = self.bm_annotation_data[model]  # type: ignore
-        else:
-            bm_rel = self.get_bm_rel(model)
-            bm_filter = self.get_my_bookmark_filter(bm_rel)
+        bm_rel, bm_filter = self.get_bookmark_rel_and_filter(model)
 
         page_rel = f"{bm_rel}__page"
         finished_rel = f"{bm_rel}__finished"
@@ -331,7 +266,7 @@ class BrowserAnnotationsView(BrowserOrderByView, SharedAnnotationsMixin):
                 output_field=PositiveSmallIntegerField(),
                 distinct=True,
             )
-            qs = qs.alias(finished_count=finished_count)
+            qs = qs.annotate(finished_count=finished_count)
             finished_aggregate = Case(
                 When(finished_count=F("child_count"), then=True),
                 When(finished_count=0, then=False),
@@ -339,20 +274,15 @@ class BrowserAnnotationsView(BrowserOrderByView, SharedAnnotationsMixin):
                 output_field=BooleanField(),
             )
 
-        if (
-            self.is_opds_1_acquisition
-            or self.is_model_comic
-            and self.TARGET == "browser"
+        if self.is_opds_1_acquisition or (
+            self.is_model_comic and self.TARGET == "browser"
         ):
             qs = qs.annotate(page=bookmark_page)
-        else:
+        elif self.TARGET in frozenset({"metadata", "browser"}):
             qs = qs.alias(page=bookmark_page)
 
         if self.TARGET in frozenset({"metadata", "browser"}):
-            qs.annotate(finished=finished_aggregate)
-        else:
-            # Only used for progress
-            qs.alias(finished=finished_aggregate)
+            qs = qs.annotate(finished=finished_aggregate)
         return qs
 
     def _annotate_progress(self, qs):
@@ -367,19 +297,26 @@ class BrowserAnnotationsView(BrowserOrderByView, SharedAnnotationsMixin):
         progress = Case(When(page_count__gt=0, then=then), default=0.0)
         return qs.annotate(progress=progress)
 
-    def _annotate_mtime(self, qs):
+    def _annotate_mtime(self, qs, model):
         """Annotations mtime."""
-        when_filter = {self.rel_prefix + "bookmark__updated_at__gt": F("updated_at")}
-        mtime = Case(
-            When(**when_filter),
-            then=F(self.rel_prefix + "bookmark__updated_at"),
-            default=F("updated_at"),
-        )
+        if self.is_bookmark_filtered:
+            sub_qs = self.get_filtered_queryset(model, bookmark_filter=False)
+            bm_rel, bm_filter = self.get_bookmark_rel_and_filter(model)
+            ua_rel = bm_rel + "__updated_at"
+            qs = qs.annotate(
+                bmu_max=Max(
+                    sub_qs.filter(pk=OuterRef("pk")).values_list(ua_rel, flat=True),
+                    default=NONE_DATETIMEFIELD,
+                    filter=bm_filter,
+                )
+            )
+            mtime = Greatest(Coalesce("bmu_max", Value(EPOCH_START)), "updated_at")
+        else:
+            mtime = F("updated_at")
         return qs.annotate(mtime=mtime)
 
     def annotate_card_aggregates(self, qs, model):
         """Annotate aggregates that appear the browser card."""
-        qs = self._annotate_cover_pk(qs, model)
         if model == Comic:
             # comic adds order_value for cards late
             qs = self._annotate_order_value(qs, model)
@@ -387,77 +324,4 @@ class BrowserAnnotationsView(BrowserOrderByView, SharedAnnotationsMixin):
         qs = self.annotate_group_names(qs, model)
         qs = self._annotate_bookmarks(qs, model)
         qs = self._annotate_progress(qs)
-        return self._annotate_mtime(qs)
-
-    def _get_cover_pk_query(self, cover_pks, group_ids):
-        """Get Cover Pk queryset for comic queryset."""
-        cover_style = self.params.get("cover_style")
-        if cover_style == "d":
-            # DYNAMIC COVERS
-            comic_qs = Comic.objects.filter(pk__in=cover_pks)
-            comic_qs = self.annotate_search_score(
-                comic_qs, Comic, self.cover_search_score_pairs
-            )
-            comic_qs = self.annotate_order_aggregates(comic_qs, Comic)
-            comic_qs = self.add_order_by(comic_qs, Comic)  # type: ignore
-        else:  # "f"
-            # FIRST COVERS
-            # The only filter at all is the model relation.
-            group_rel = _REL_MAP[self.model]  # type: ignore
-            comic_qs = Comic.objects.filter(**{f"{group_rel}__in": group_ids})
-
-            # Order generated irrespective of browser filters and order
-            if self.kwargs["group"] == "f":
-                order_key = "filename"
-            elif self.kwargs["group"] == "a":
-                order_key = "story_arc_number"
-            else:
-                order_key = "sort_name"
-
-            model_group = self.model_group  # type: ignore
-            show = MappingProxyType(self.params["show"])  # type: ignore
-            model_group = self.kwargs["group"]
-            comic_qs, comic_sort_names = self.alias_sort_names(
-                comic_qs, Comic, cover_pks, model_group, show
-            )
-            comic_qs = self.add_order_by(
-                comic_qs,
-                Comic,
-                order_key=order_key,
-                do_reverse=False,
-                comic_sort_names=comic_sort_names,
-            )
-        comic_qs = comic_qs.group_by("id")
-        return comic_qs.only("pk", "updated_at")
-
-    def re_cover_multi_groups(self, group_qs):
-        """Python hack to re-cover groups collapsed with group_by."""
-        # This would be better in the main query but OuterRef can't access annotations.
-        # So cover_pks aggregates all covers from multi groups like ids does.
-        cover_style = self.params.get("cover_style")
-        if self.is_model_comic or cover_style == "i":
-            return group_qs
-
-        recovered_group_list = []
-        for group in group_qs:
-            cover_pks = group.cover_pks
-            if len(cover_pks) == 1:
-                cover_pk = cover_pks[0]
-            else:
-                comic_qs = self._get_cover_pk_query(cover_pks, group.ids)
-                # print(comic_qs.explain())
-                # print(comic_qs.query)
-                cover = comic_qs[0]
-                cover_pk = cover.pk
-
-            if len(group.ids) == 1:
-                cover_mtime = group.updated_at
-            else:
-                cover_mtime = group.__class__.objects.filter(
-                    pk__in=group.ids
-                ).aggregate(updated_at=Max("updated_at"))["updated_at"]
-
-            group.cover_mtime = cover_mtime
-            group.cover_pk = cover_pk
-            recovered_group_list.append(group)
-        return recovered_group_list
+        return self._annotate_mtime(qs, model)

codex/views/browser/base.py

@@ -4,7 +4,6 @@ from types import MappingProxyType
 from typing import TYPE_CHECKING, Any
 
 from django.contrib.auth.models import User
-from django.db.models import Q
 from django.db.models.aggregates import Max, Min
 from rest_framework.exceptions import NotFound
 
@@ -12,20 +11,17 @@ from codex.logger.logging import get_logger
 from codex.models import (
     AdminFlag,
     Comic,
-    Folder,
 )
 from codex.serializers.browser.settings import BrowserSettingsSerializer
 from codex.views.browser.filters.search import SearchFilterView
 from codex.views.const import GROUP_MODEL_MAP, ROOT_GROUP
-from codex.views.utils import reparse_json_query_params
+from codex.views.util import reparse_json_query_params
 
 LOG = get_logger(__name__)
 
 if TYPE_CHECKING:
     from codex.models.groups import BrowserGroupModel
 
-_REPARSE_JSON_FIELDS = frozenset({"filters", "show"})
-
 
 class BrowserBaseView(SearchFilterView):
     """Browse comics with a variety of filters and sorts."""
@@ -33,16 +29,15 @@ class BrowserBaseView(SearchFilterView):
     input_serializer_class = BrowserSettingsSerializer
 
     ADMIN_FLAG_VALUE_KEY_MAP = MappingProxyType({})
+    REPARSE_JSON_FIELDS = frozenset({"filters", "show"})
 
     _GET_JSON_KEYS = frozenset({"filters", "show"})
-    TARGET = ""
 
     def __init__(self, *args, **kwargs):
         """Set params for the type checker."""
         super().__init__(*args, **kwargs)
         self._is_admin: bool = False
         self.params: MappingProxyType[str, Any] = MappingProxyType({})
-        self.bm_annotation_data = {}
         self.rel_prefix: str = ""
         self.model: type[BrowserGroupModel] | None = None
         self.group_class: type[BrowserGroupModel] | None = None
@@ -77,23 +72,11 @@ class BrowserBaseView(SearchFilterView):
             group = self.params["top_group"]
         return group
 
-    def get_query_filters_without_group(self, model, cover=False):
-        """Return all the filters except the group filter."""
-        add_acl = not (cover and self.model == Folder)  # type: ignore
-        object_filter = self.get_group_acl_filter(model) if add_acl else Q()
-        object_filter &= self.get_bookmark_filter(model)
-        object_filter &= self.get_comic_field_filter(model)
-        return object_filter
-
-    def get_query_filters(self, model, choices=False):
-        """Return the main object filter and the one for aggregates."""
-        object_filter = self.get_query_filters_without_group(model)
-        object_filter &= self.get_group_filter(choices)
-        return object_filter
-
     def _parse_query_params(self):
         """Parse GET query parameters: filter object & snake case."""
-        query_params = reparse_json_query_params(self.request.GET, _REPARSE_JSON_FIELDS)
+        query_params = reparse_json_query_params(
+            self.request.GET, self.REPARSE_JSON_FIELDS
+        )
         if "q" not in query_params and (query := query_params.get("query")):
             # parse query param for opds v2
             query_params["q"] = query
@@ -106,6 +89,7 @@ class BrowserBaseView(SearchFilterView):
         serializer.is_valid(raise_exception=True)
         self.load_params_from_session(serializer.validated_data)
         self.is_bookmark_filtered = bool(self.params.get("filters", {}).get("bookmark"))
+        return serializer.validated_data
 
     def set_order_key(self):
         """Unused until browser."""

codex/views/browser/breadcrumbs.py

@@ -5,13 +5,11 @@ from types import MappingProxyType
 
 from codex.logger.logging import get_logger
 from codex.views.browser.paginate import BrowserPaginateView
-from codex.views.const import FOLDER_GROUP, GROUP_NAME_MAP, STORY_ARC_GROUP
+from codex.views.const import FOLDER_GROUP, GROUP_NAME_MAP, GROUP_ORDER, STORY_ARC_GROUP
 from codex.views.util import Route
 
 LOG = get_logger(__name__)
 
-_GROUP_ORDER = "rpisv"  # TODO move to const
-
 
 class BrowserBreadcrumbsView(BrowserPaginateView):
     """Browser breadcrumbs calculations."""
@@ -69,9 +67,11 @@ class BrowserBreadcrumbsView(BrowserPaginateView):
 
         reversed_breadcrumbs = list(reversed(old_breadcrumbs))
 
+        pks = self.kwargs["pks"]
+        page = self.kwargs["page"]
         folder = self.group_instance  # type: ignore
-        name = folder.name if folder else "All"
-        group_crumb = Route(FOLDER_GROUP, self.kwargs["pks"], self.kwargs["page"], name)
+        name = folder.name if folder and pks else ""
+        group_crumb = Route(FOLDER_GROUP, pks, page, name)
         new_breadcrumbs = []
 
         while True:
@@ -89,11 +89,13 @@ class BrowserBreadcrumbsView(BrowserPaginateView):
                 break
 
             # parent next
+            if not folder:
+                break
             folder = folder.parent_folder
             if folder:
                 group_crumb = Route(FOLDER_GROUP, (folder.pk,), 1, name=folder.name)
             else:
-                group_crumb = Route(FOLDER_GROUP, (), 1, name="All")
+                group_crumb = Route(FOLDER_GROUP, (), 1, name="")
 
         breadcrumbs = new_breadcrumbs
 
@@ -105,12 +107,12 @@ class BrowserBreadcrumbsView(BrowserPaginateView):
         if not gi:
             pks = ()
             page = 1
-            name = "All"
+            name = ""
         if group == self.kwargs["group"]:
             # create self crumb
             pks = self.kwargs["pks"]
             page = self.kwargs["page"]
-            name = gi.name if gi else "All"
+            name = gi.name if gi else ""
         else:
             page = 1
             if (attr := GROUP_NAME_MAP.get(group)) and (
@@ -120,7 +122,7 @@ class BrowserBreadcrumbsView(BrowserPaginateView):
                 name = parent_group.name
             else:
                 pks = ()
-                name = "All"
+                name = ""
 
         return Route(group, pks, page, name)
 
@@ -147,29 +149,29 @@ class BrowserBreadcrumbsView(BrowserPaginateView):
 
     def _breadcrumbs_graft_or_create_group(self) -> tuple[tuple[Route, ...], bool]:
         """Graft or create browse group breadcrumbs."""
-        old_breadcrumbs, changed = self._init_breadcrumbs(_GROUP_ORDER)
+        old_breadcrumbs, changed = self._init_breadcrumbs(GROUP_ORDER)
 
         vng = self.valid_nav_groups  # type: ignore
         test_groups = tuple(reversed(vng[:-1]))
         new_breadcrumbs = []
         level = done = False
         try:
-            browser_group_index = _GROUP_ORDER.index(self.kwargs["group"])
+            browser_group_index = GROUP_ORDER.index(self.kwargs["group"])
         except ValueError:
             browser_group_index = -1
 
         for group in test_groups:
             try:
                 with suppress(ValueError):
-                    level = level or _GROUP_ORDER.index(group) <= browser_group_index
+                    level = level or GROUP_ORDER.index(group) <= browser_group_index
                 if level:
                     done, changed = self._breadcrumbs_graft_or_create_group_crumb(
                         group, old_breadcrumbs, new_breadcrumbs, changed
                     )
                 try:
-                    if old_breadcrumbs and _GROUP_ORDER.index(
+                    if old_breadcrumbs and GROUP_ORDER.index(
                         old_breadcrumbs[-1].group
-                    ) >= _GROUP_ORDER.index(group):
+                    ) >= GROUP_ORDER.index(group):
                         # Trim old_breadcrumbs to match to group
                         old_breadcrumbs.pop(-1)
                 except ValueError:

codex/views/browser/browser.py

@@ -22,7 +22,6 @@ from codex.models import (
     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,
@@ -121,9 +120,7 @@ class BrowserView(BrowserTitleView):
     ################
     def _get_common_queryset(self, model):
         """Create queryset common to group & books."""
-        object_filter = self.get_query_filters(model, False)
-        qs = model.objects.filter(object_filter)
-        qs = self.filter_by_annotations(qs, model)
+        qs = self.get_filtered_queryset(model)
         count_group_by = self.get_group_by(model)
         count = qs.group_by(count_group_by).count()
         if count:
@@ -159,16 +156,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)
 
     @staticmethod
     def _get_zero_pad(book_qs):
@@ -189,9 +183,6 @@ class BrowserView(BrowserTitleView):
         group_qs, book_qs, num_pages, page_group_count, page_book_count = self.paginate(
             group_qs, book_qs, group_count, book_count
         )
-        mtime = self._get_page_mtime(
-            group_qs
-        )  # TODO should this be after paginate or not?
         if page_group_count:
             group_qs = self.annotate_card_aggregates(group_qs, self.model)
         if page_book_count:
@@ -203,13 +194,13 @@ class BrowserView(BrowserTitleView):
         # print(group_qs.explain())
         # print(group_qs.query)
 
-        recovered_group_list = self.re_cover_multi_groups(group_qs)
         total_count = page_group_count + page_book_count
-        return recovered_group_list, book_qs, num_pages, total_count, zero_pad, mtime
+        mtime = self._get_page_mtime()
+        return group_qs, book_qs, num_pages, total_count, zero_pad, mtime
 
     def get_object(self):
         """Validate settings and get the querysets."""
-        group_list, book_qs, num_pages, total_count, zero_pad, mtime = (
+        group_qs, book_qs, num_pages, total_count, zero_pad, mtime = (
             self._get_group_and_books()
         )
 
@@ -226,7 +217,7 @@ class BrowserView(BrowserTitleView):
                 "breadcrumbs": parent_breadcrumbs,
                 "title": title,
                 "model_group": self.model_group,
-                "groups": group_list,
+                "groups": group_qs,
                 "books": book_qs,
                 "zero_pad": zero_pad,
                 "num_pages": num_pages,