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

codex/views/browser/{annotations.py → browser_annotations.py}

@@ -7,8 +7,10 @@ from django.db.models import (
     Avg,
     BooleanField,
     Case,
+    DateTimeField,
     F,
     FilteredRelation,
+    Max,
     Min,
     Q,
     Sum,
@@ -18,58 +20,46 @@ from django.db.models import (
 from django.db.models.fields import CharField, PositiveSmallIntegerField
 from django.db.models.functions import Least, Reverse, Right, StrIndex
 
-from codex.logger.logging import get_logger
-from codex.models import (
-    BrowserGroupModel,
-    Comic,
-    Folder,
-    StoryArc,
-    Volume,
-)
+from codex.models import BrowserGroupModel, Comic, Folder, StoryArc, Volume
 from codex.models.functions import JsonGroupArray
-from codex.views.browser.order_by import (
+from codex.views.browser.browser_order_by import (
     BrowserOrderByView,
 )
-from codex.views.const import (
-    NONE_DATETIMEFIELD,
-    NONE_INTEGERFIELD,
-    STORY_ARC_GROUP,
-)
 from codex.views.mixins import SharedAnnotationsMixin
 
-_ORDER_AGGREGATE_FUNCS = MappingProxyType(
-    # These are annotated to order_value because they're simple relations
-    {
-        "age_rating": Avg,
-        "community_rating": Avg,
-        "created_at": Min,
-        "critical_rating": Avg,
-        "date": Min,
-        "page_count": Sum,
-        "size": Sum,
-        "updated_at": Min,
-    }
-)
-_ANNOTATED_ORDER_FIELDS = frozenset(
-    # These are annotated with their own functions
-    {
-        "filename",
-        "sort_name",
-        "search_score",
-        "bookmark_updated_at",
-        "story_arc_number",
-    }
-)
-_ALTERNATE_GROUP_BY: MappingProxyType[type[BrowserGroupModel], str] = MappingProxyType(
-    {Comic: "id", Volume: "name", Folder: "name"}
-)
-
-LOG = get_logger(__name__)
-
 
 class BrowserAnnotationsView(BrowserOrderByView, SharedAnnotationsMixin):
     """Base class for views that need special metadata annotations."""
 
+    _NONE_INTEGERFIELD = Value(None, PositiveSmallIntegerField())
+    _NONE_DATETIMEFIELD = Value(None, DateTimeField())
+    _ORDER_AGGREGATE_FUNCS = MappingProxyType(
+        # These are annotated to order_value becauase they're simple relations
+        {
+            "age_rating": Avg,
+            "community_rating": Avg,
+            "created_at": Min,
+            "critical_rating": Avg,
+            "date": Min,
+            "page_count": Sum,
+            "size": Sum,
+            "updated_at": Min,
+        }
+    )
+    _ANNOTATED_ORDER_FIELDS = frozenset(
+        # These are annotated with their own functions
+        {
+            "filename",
+            "sort_name",
+            "search_score",
+            "bookmark_updated_at",
+            "story_arc_number",
+        }
+    )
+    _ALTERNATE_GROUP_BY: MappingProxyType[type[BrowserGroupModel], str] = (
+        MappingProxyType({Comic: "id", Volume: "name"})
+    )
+
     def __init__(self, *args, **kwargs):
         """Set params for the type checker."""
         super().__init__(*args, **kwargs)
@@ -81,7 +71,7 @@ class BrowserAnnotationsView(BrowserOrderByView, SharedAnnotationsMixin):
         """Get the group by for the model."""
         if model is None:
             model = self.model
-        return _ALTERNATE_GROUP_BY.get(model, "sort_name")  # type: ignore
+        return self._ALTERNATE_GROUP_BY.get(model, "sort_name")  # type: ignore
 
     def _alias_sort_names(self, qs, model):
         """Annotate sort_name."""
@@ -122,7 +112,7 @@ class BrowserAnnotationsView(BrowserOrderByView, SharedAnnotationsMixin):
         # Get story_arc__pk
         group = self.kwargs["group"]
         pks = self.kwargs["pks"]
-        if group == STORY_ARC_GROUP and pks:
+        if group == self.STORY_ARC_GROUP and pks:
             story_arc_pks = pks
         else:
             story_arc_pks = self.params.get("filters", {}).get(  # type: ignore
@@ -139,7 +129,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 = self._NONE_INTEGERFIELD
 
         return qs.alias(story_arc_number=story_arc_number)
 
@@ -158,27 +148,33 @@ class BrowserAnnotationsView(BrowserOrderByView, SharedAnnotationsMixin):
         return qs
 
     def _annotate_bookmark_updated_at(self, qs, model):
-        if not self.is_opds_1_acquisition and self.order_key != "bookmark_updated_at":
-            return qs
-        bm_rel, bm_filter = self.get_bookmark_rel_and_filter(model)
-        bm_updated_at_rel = f"{bm_rel}__updated_at"
-        bmua_agg = self.order_agg_func(
-            bm_updated_at_rel, default=NONE_DATETIMEFIELD, filter=bm_filter
-        )
-        return qs.annotate(bookmark_updated_at=bmua_agg)
+        if self.is_opds_1_acquisition or self.order_key == "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
+
+            updated_at_rel = f"{bm_rel}__updated_at"
+            bookmark_updated_at_aggregate = self.order_agg_func(
+                updated_at_rel,
+                default=self._NONE_DATETIMEFIELD,
+                filter=bm_filter,
+            )
+            if self.TARGET == "opds1":
+                qs = qs.annotate(bookmark_updated_at=bookmark_updated_at_aggregate)
+            else:
+                qs = qs.alias(bookmark_updated_at=bookmark_updated_at_aggregate)
+        return qs
 
     def _annotate_order_value(self, qs, model):
         """Annotate a main key for sorting and browser card display."""
         # Determine order func
-        if self.TARGET == "metadata":
-            return qs
         if model == Folder and self.order_key == "filename":
             order_value = F("name")
-        elif model == Comic or self.order_key in _ANNOTATED_ORDER_FIELDS:
+        elif model == Comic or self.order_key in self._ANNOTATED_ORDER_FIELDS:
             # These are annotated in browser_annotaions
             order_value = F(self.order_key)
         else:
-            agg_func = _ORDER_AGGREGATE_FUNCS[self.order_key]
+            agg_func = self._ORDER_AGGREGATE_FUNCS[self.order_key]
             agg_func = self.order_agg_func if agg_func == Min else agg_func
             field = self.rel_prefix + self.order_key
             order_value = agg_func(field)
@@ -191,6 +187,7 @@ class BrowserAnnotationsView(BrowserOrderByView, SharedAnnotationsMixin):
 
     def annotate_order_aggregates(self, qs, model):
         """Annotate common aggregates between browser and metadata."""
+        # ids coming first or before cover_qs works.
         qs = qs.annotate(ids=JsonGroupArray("id", distinct=True))
         qs = self._alias_sort_names(qs, model)
         qs = self._alias_filename(qs, model)
@@ -202,6 +199,19 @@ 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
+        if model == Comic:
+            qs = qs.annotate(cover_pk=F("pk"))
+            qs = qs.annotate(cover_mtime=F("updated_at"))
+        elif self.admin_flags["dynamic_group_covers"]:
+            # At this point it's only been filtered.
+            qs = qs.annotate(cover_pk=F(self.rel_prefix + "pk"))
+            qs = qs.annotate(cover_pks=JsonGroupArray("cover_pk", distinct=True))
+        return qs
+
     def _annotate_group(self, qs, model):
         """Annotate Group."""
         value = "c" if model == Comic else self.model_group  # type: ignore
@@ -209,7 +219,11 @@ class BrowserAnnotationsView(BrowserOrderByView, SharedAnnotationsMixin):
 
     def _annotate_bookmarks(self, qs, model):
         """Hoist up bookmark annotations."""
-        bm_rel, bm_filter = self.get_bookmark_rel_and_filter(model)
+        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)
 
         page_rel = f"{bm_rel}__page"
         finished_rel = f"{bm_rel}__finished"
@@ -250,7 +264,7 @@ class BrowserAnnotationsView(BrowserOrderByView, SharedAnnotationsMixin):
                 output_field=PositiveSmallIntegerField(),
                 distinct=True,
             )
-            qs = qs.annotate(finished_count=finished_count)
+            qs = qs.alias(finished_count=finished_count)
             finished_aggregate = Case(
                 When(finished_count=F("child_count"), then=True),
                 When(finished_count=0, then=False),
@@ -258,15 +272,16 @@ 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:
             qs = qs.annotate(page=bookmark_page)
-        elif self.TARGET in frozenset({"metadata", "browser"}):
+        else:
             qs = qs.alias(page=bookmark_page)
 
         if self.TARGET in frozenset({"metadata", "browser"}):
-            qs = qs.annotate(finished=finished_aggregate)
+            qs.annotate(finished=finished_aggregate)
+        else:
+            # Only used for progress
+            qs.alias(finished=finished_aggregate)
         return qs
 
     def _annotate_progress(self, qs):
@@ -283,11 +298,50 @@ class BrowserAnnotationsView(BrowserOrderByView, SharedAnnotationsMixin):
 
     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)
         qs = self._annotate_group(qs, model)
         qs = self.annotate_group_names(qs, model)
         qs = self._annotate_bookmarks(qs, model)
-        qs = self._annotate_progress(qs)
-        return qs.annotate(updated_ats=JsonGroupArray("updated_at", distinct=True))
+        return self._annotate_progress(qs)
+
+    def annotate_for_metadata(self, qs, _model):
+        """Annotations only for metadata."""
+        return qs.annotate(mtime=Max("updated_at"))
+
+    def _get_cover_pk_query(self, cover_pks):
+        """Get Cover Pk queryset for comic queryset."""
+        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
+        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.
+        if self.is_model_comic or not self.admin_flags["dynamic_group_covers"]:  # type: ignore
+            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]
+                cover_updated_at = group.updated_at
+            else:
+                comic_qs = self._get_cover_pk_query(cover_pks)
+                # print(comic_qs.explain())
+                # print(comic_qs.query)
+                cover = comic_qs[0]
+                cover_pk = cover.pk
+                cover_updated_at = cover.updated_at
+            group.cover_pk = cover_pk
+            group.cover_mtime = cover_updated_at
+            recovered_group_list.append(group)
+        return recovered_group_list

codex/views/browser/browser_breadcrumbs.py

@@ -0,0 +1,175 @@
+"""Browser breadcrumbs calculations."""
+
+from types import MappingProxyType
+from typing import TYPE_CHECKING
+
+from codex.views.browser.browser_annotations import BrowserAnnotationsView
+from codex.views.const import GROUP_NAME_MAP
+
+if TYPE_CHECKING:
+    from codex.models.paths import Folder
+
+
+class BrowserBreadcrumbsView(BrowserAnnotationsView):
+    """Browser breadcrumbs calculations."""
+
+    def _is_breadcrumbs_child_folder(self, is_child, group, up_group, up_pks) -> bool:
+        """Is this page a child of the folder breadcrumbs."""
+        if group != up_group or not self.group_instance:  # type: ignore
+            return is_child
+        parent_folder: Folder | None = self.group_instance.parent_folder  # type: ignore
+        parent_pk = parent_folder.pk if parent_folder else 0
+        return parent_pk in up_pks or (not up_pks and not parent_pk)
+
+    def _is_breadcrumbs_child_groups(self, is_child, group, up_group, up_pks):
+        """Is this page a child of the group breadcrumbs."""
+        show = self.params["show"]
+        test_parent = False
+        parent_group = None
+        for show_group, enabled in reversed(show.items()):
+            if not test_parent:
+                if show_group == group:
+                    test_parent = True
+                continue
+            if not enabled:
+                continue
+            group_name = GROUP_NAME_MAP[show_group]
+            parent_group = getattr(self.group_instance, group_name, None)  # type: ignore
+            is_child = bool(parent_group) and (parent_group.pk in up_pks)
+            break
+        if up_group == "r" and not parent_group:
+            is_child = True
+        return is_child
+
+    def _is_breadcrumbs_child(self, breadcrumbs) -> bool:
+        """Is the current route a child of the stored breadcrumbs."""
+        is_child = False
+        if not breadcrumbs:
+            return is_child
+        group = self.kwargs["group"]
+        pks = self.kwargs["pks"]
+        up_route = breadcrumbs[-1]
+        up_group = up_route["group"]
+        up_pks = up_route["pks"]
+        if group == self.STORY_ARC_GROUP:
+            is_child = group == up_group and pks
+        elif group == self.FOLDER_GROUP:
+            is_child = self._is_breadcrumbs_child_folder(
+                is_child, group, up_group, up_pks
+            )
+        else:
+            is_child = self._is_breadcrumbs_child_groups(
+                is_child, group, up_group, up_pks
+            )
+
+        return is_child
+
+    def _create_breadcrumbs_story_arc(self):
+        """Create the only story_arc parent."""
+        return [
+            {
+                "group": self.STORY_ARC_GROUP,
+                "pks": (),
+                "page": 1,
+                "name": "",
+            }
+        ]
+
+    def _create_breadcrumbs_folder(self):
+        """Create folder parents."""
+        breadcrumbs = []
+        folder: Folder | None = self.group_instance  # type: ignore
+        while folder:
+            folder = folder.parent_folder  # type: ignore
+            pks = (folder.pk,) if folder else ()
+            name = folder.name if folder else ""
+            parent_route = {
+                "group": self.FOLDER_GROUP,
+                "pks": pks,
+                "page": 1,
+                "name": name,
+            }
+            breadcrumbs = [parent_route, *breadcrumbs]
+        return breadcrumbs
+
+    def _create_breadcrumbs_group(self):
+        """Create browse group parents."""
+        breadcrumbs = [{"group": self.ROOT_GROUP, "pks": (), "page": 1, "name": ""}]
+        show = self.params["show"]
+        for show_group, enabled in show.items():
+            if not enabled or show_group not in self.valid_nav_groups:  # type: ignore
+                continue
+            attr = GROUP_NAME_MAP[show_group]  # + "_id"
+            parent_group = getattr(self.group_instance, attr, None)  # type: ignore
+            if parent_group:
+                pks = (parent_group.pk,)
+                name = parent_group.name
+                parent_group_route = {
+                    "group": show_group,
+                    "pks": pks,
+                    "page": 1,
+                    "name": name,
+                }
+                breadcrumbs += [parent_group_route]
+        return breadcrumbs
+
+    def _create_breadcrumbs(self):
+        """Create breadcrumbs from scratch."""
+        pks = self.kwargs["pks"]
+        if not pks:
+            return []
+        group = self.kwargs["group"]
+        if group == self.STORY_ARC_GROUP:
+            breadcrumbs = self._create_breadcrumbs_story_arc()
+        elif group == self.FOLDER_GROUP:
+            breadcrumbs = self._create_breadcrumbs_folder()
+        else:
+            breadcrumbs = self._create_breadcrumbs_group()
+        return breadcrumbs
+
+    def _is_breadcrumbs_identical(self, breadcrumbs):
+        if not breadcrumbs:
+            return False
+
+        up_route = breadcrumbs[-1]
+        if not up_route:
+            return False
+
+        group = self.kwargs["group"]
+        if up_route["group"] != group:
+            return False
+
+        pks = self.kwargs["pks"]
+        if set(up_route["pks"]) != set(pks):
+            return False
+
+        return True
+
+    def get_parent_breadcrumbs(
+        self,
+    ) -> tuple[dict[str, str | tuple[int, ...] | int], ...]:
+        """Get the breadcrumbs."""
+        breadcrumbs: list[dict[str, str | tuple[int, ...] | int]] = list(
+            self.get_from_session("breadcrumbs")
+        )
+
+        if not self._is_breadcrumbs_identical(breadcrumbs):
+            if not self._is_breadcrumbs_child(breadcrumbs):
+                breadcrumbs = self._create_breadcrumbs()
+
+            # Add current route to crumbs
+            group = self.kwargs["group"]
+            pks = self.kwargs["pks"]
+            name = self.group_instance.name if self.group_instance else ""  # type: ignore
+            page = self.kwargs["page"]
+            route = {"group": group, "pks": pks, "page": page, "name": name}
+            breadcrumbs += [route]
+
+            # Save params
+            params = dict(self.params)
+            params["breadcrumbs"] = breadcrumbs
+            self.params = MappingProxyType(params)
+
+        parent_breadcrumbs = breadcrumbs[:-1] if breadcrumbs else ()
+
+        return tuple(parent_breadcrumbs)

codex/views/browser/browser_order_by.py

@@ -0,0 +1,63 @@
+"""Base view for ordering the query."""
+
+from django.db.models.aggregates import Max, Min
+
+from codex.models import Comic
+from codex.views.browser.filters.annotations import (
+    BrowserAnnotationsFilterView,
+)
+
+
+class BrowserOrderByView(BrowserAnnotationsFilterView):
+    """Base class for views that need ordering."""
+
+    def __init__(self, *args, **kwargs):
+        """Set params for the type checker."""
+        super().__init__(*args, **kwargs)
+        self.order_key: str = ""
+
+    def set_order_key(self):
+        """Get the default order key for the view."""
+        order_key: str = self.params.get("order_by", "")  # type: ignore
+        if not order_key:
+            group = self.kwargs.get("group")
+            order_key = "filename" if group == self.FOLDER_GROUP else "sort_name"
+        self.order_key: str = order_key
+        order_reverse = self.params.get("order_reverse")
+        self.order_agg_func = Max if order_reverse else Min
+
+    def add_order_by(self, qs, model):
+        """Create the order_by list."""
+        order_fields_head = None
+        if model == Comic:
+            if self.order_key == "sort_name":
+                order_fields_head = [
+                    *self.comic_sort_names,  # type: ignore
+                    "issue_number",
+                    "issue_suffix",
+                    "sort_name",
+                ]
+            else:
+                # Comic orders on indexed fields directly
+                # Which is allegedly faster than using tmp b-trees (annotations)
+                # And since that's every cover sort, it's worth it.
+                order_fields_head = [self.order_key]
+                # Comic order micro optimizations
+                if self.order_key == "story_arc_number":
+                    order_fields_head += ["date"]
+                elif self.order_key == "bookmark_updated_at":
+                    order_fields_head += ["updated_at"]
+        else:
+            order_fields_head = ["order_value"]
+
+        order_fields = (*order_fields_head, "pk")
+
+        prefix = "-" if self.params.get("order_reverse") else ""
+        order_by = []
+        if prefix:
+            for field in order_fields:
+                order_by.append(prefix + field)
+        else:
+            order_by = order_fields
+
+        return qs.order_by(*order_by)