codex 1.7.0a0__py3-none-any.whl → 1.7.0a2__py3-none-any.whl

codex/views/browser/annotate/bookmark.py

@@ -0,0 +1,112 @@
+"""Base view for metadata annotations."""
+
+from django.db.models import (
+    Case,
+    F,
+    Sum,
+    Value,
+    When,
+)
+from django.db.models.fields import BooleanField, PositiveSmallIntegerField
+from django.db.models.functions import Least
+from django.db.models.functions.comparison import Coalesce
+
+from codex.logger.logging import get_logger
+from codex.models import (
+    Comic,
+)
+from codex.models.functions import JsonGroupArray
+from codex.views.browser.annotate.order import BrowserAnnotateOrderView
+
+LOG = get_logger(__name__)
+
+
+class BrowserAnnotateBookmarkView(BrowserAnnotateOrderView):
+    """Base class for views that need special metadata annotations."""
+
+    def _get_group_bookmark_page_annotation(
+        self, qs, bm_rel, bm_filter, page_rel, finished_rel
+    ):
+        """Get bookmark page subquery."""
+        finished_filter = {finished_rel: True}
+        prefix = "" if qs.model is Comic else self.rel_prefix
+        page_count = prefix + "page_count"
+        # Can't use a filtered relation for page & finished because of this
+        # page_count case.
+        bookmark_page_case = Case(
+            When(**{bm_rel: None}, then=0),
+            When(**finished_filter, then=page_count),
+            default=page_rel,
+            output_field=PositiveSmallIntegerField(),
+        )
+        return Sum(
+            bookmark_page_case,
+            default=0,
+            filter=bm_filter,
+            output_field=PositiveSmallIntegerField(),
+            distinct=True,
+        )
+
+    @classmethod
+    def _get_group_bookmark_finished_annotation(cls, qs, bm_filter, finished_rel):
+        """Get finished_count subquery."""
+        finished_count = Sum(
+            finished_rel,
+            default=0,
+            filter=bm_filter,
+            output_field=PositiveSmallIntegerField(),
+            # distinct breaks this sum and only returns one. idk why.
+        )
+        qs = qs.alias(finished_count=finished_count)
+
+        finished_aggregate = Case(
+            When(finished_count=F("child_count"), then=True),
+            When(finished_count=0, then=False),
+            default=None,
+            output_field=BooleanField(),
+        )
+        return qs, finished_aggregate
+
+    def annotate_bookmarks(self, qs):
+        """Hoist up bookmark annotations."""
+        bm_rel = self._get_bm_rel(qs.model)
+        bm_filter = self._get_my_bookmark_filter(bm_rel)
+        page_rel = f"{bm_rel}__page"
+        finished_rel = f"{bm_rel}__finished"
+
+        if qs.model is Comic:
+            bookmark_page = Sum(page_rel, filter=bm_filter, default=0)
+            finished_aggregate = Sum(finished_rel, filter=bm_filter, default=False)
+        else:
+            bookmark_page = self._get_group_bookmark_page_annotation(
+                qs, bm_rel, bm_filter, page_rel, finished_rel
+            )
+            qs, finished_aggregate = self._get_group_bookmark_finished_annotation(
+                qs, bm_filter, finished_rel
+            )
+
+        if (
+            (self.TARGET == "browser" and qs.model is Comic)
+            or self.is_opds_acquisition
+            or self.TARGET == "metadata"
+        ):
+            qs = qs.annotate(page=bookmark_page)
+        else:
+            qs = qs.alias(page=bookmark_page)
+
+        qs = qs.annotate(finished=finished_aggregate)
+
+        if not self.bmua_is_max:
+            mbmua = self.get_max_bookmark_updated_at_aggregate(qs.model, JsonGroupArray)
+            qs = qs.annotate(bookmark_updated_ats=mbmua)
+        return qs
+
+    def annotate_progress(self, qs):
+        """Compute progress for each member of a qs."""
+        # Requires bookmark and annotation hoisted from bookmarks.
+        # Requires page_count native to comic or aggregated
+        # Page counts can be null with metadata turned off.
+        # Least guard is for rare instances when bookmarks are set to
+        # invalid high values
+        progress = Least(Coalesce(F("page"), 0) * 100.0 / F("page_count"), Value(100.0))
+        return qs.annotate(progress=progress)

codex/views/browser/annotate/card.py

@@ -0,0 +1,61 @@
+"""Base view for metadata annotations."""
+
+from types import MappingProxyType
+
+from django.db.models import (
+    Value,
+)
+from django.db.models.aggregates import Count
+from django.db.models.fields import CharField
+
+from codex.logger.logging import get_logger
+from codex.models.comic import Comic
+from codex.models.functions import JsonGroupArray
+from codex.models.groups import BrowserGroupModel, Imprint, Publisher, Series, Volume
+from codex.views.browser.annotate.bookmark import BrowserAnnotateBookmarkView
+
+_GROUP_BY: MappingProxyType[type[BrowserGroupModel], str] = MappingProxyType(
+    {Publisher: "sort_name", Imprint: "sort_name", Series: "sort_name", Volume: "name"}
+)
+LOG = get_logger(__name__)
+
+
+class BrowserAnnotateCardView(BrowserAnnotateBookmarkView):
+    """Base class for views that need special metadata annotations."""
+
+    def add_group_by(self, qs):
+        """Get the group by for the model."""
+        if group_by := _GROUP_BY.get(qs.model):  # type: ignore
+            qs = qs.group_by(group_by)
+        return qs
+
+    def _annotate_child_count(self, qs):
+        """Annotate child chount for card."""
+        if qs.model is Comic:
+            return qs
+        rel = self.rel_prefix + "pk"
+        count_func = Count(rel, distinct=True)
+        ann = {"child_count": count_func}
+        if self.TARGET == "opds2":
+            if qs.model is not Comic:
+                qs = qs.alias(**ann)
+        else:
+            qs = qs.annotate(**ann)
+        return qs
+
+    def _annotate_group(self, qs):
+        """Annotate Group."""
+        value = "c" if qs.model is Comic else self.model_group  # type: ignore
+        return qs.annotate(group=Value(value, CharField(max_length=1)))
+
+    def annotate_card_aggregates(self, qs):
+        """Annotate aggregates that appear the browser card."""
+        if qs.model is Comic:
+            # comic adds order_value for cards late
+            qs = self.annotate_order_value(qs)
+        qs = self._annotate_group(qs)
+        qs = self.annotate_group_names(qs)
+        qs = self._annotate_child_count(qs)
+        qs = self.annotate_bookmarks(qs)
+        qs = self.annotate_progress(qs)
+        return qs.annotate(updated_ats=JsonGroupArray("updated_at", distinct=True))

codex/views/browser/annotate/order.py

@@ -0,0 +1,247 @@
+"""Base view for metadata annotations."""
+
+from os import sep
+from types import MappingProxyType
+
+from django.db.models import (
+    F,
+    FilteredRelation,
+    Q,
+    Value,
+)
+from django.db.models.aggregates import Avg, Max, Min, Sum
+from django.db.models.fields import CharField
+from django.db.models.functions import Reverse, Right, StrIndex
+
+from codex.logger.logging import get_logger
+from codex.models import (
+    Comic,
+    Folder,
+    StoryArc,
+)
+from codex.models.functions import ComicFTSRank, JsonGroupArray
+from codex.views.browser.order_by import (
+    BrowserOrderByView,
+)
+from codex.views.const import (
+    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",
+    }
+)
+
+LOG = get_logger(__name__)
+
+
+class BrowserAnnotateOrderView(BrowserOrderByView, SharedAnnotationsMixin):
+    """Base class for views that need special metadata annotations."""
+
+    CARD_TARGETS = frozenset({"browser", "metadata"})
+    _OPDS_TARGETS = frozenset({"opds1", "opds2"})
+    _PAGE_COUNT_TARGETS = frozenset(CARD_TARGETS | _OPDS_TARGETS)
+    _COVER_AND_CARD_TARGETS = frozenset(CARD_TARGETS | {"cover"})
+
+    def __init__(self, *args, **kwargs):
+        """Set params for the type checker."""
+        super().__init__(*args, **kwargs)
+        self._order_agg_func: type[Min | Max] | None = None
+        self._is_opds_acquisition: bool | None = None
+        self._opds_acquisition_groups: frozenset[str] | None = None
+        self.bmua_is_max = False
+
+    @property
+    def opds_acquisition_groups(self):
+        """Memoize the opds acquisition groups."""
+        if self._opds_acquisition_groups is None:
+            groups = {"a", "f", "c"}
+            groups |= {*self.valid_nav_groups[-2:]}
+            self._opds_acquisition_groups = frozenset(groups)
+        return self._opds_acquisition_groups
+
+    @property
+    def is_opds_acquisition(self):
+        """Memoize if we're in an opds acquisition view."""
+        if self._is_opds_acquisition is None:
+            is_opds_acquisition = self.TARGET in self._OPDS_TARGETS
+            if is_opds_acquisition:
+                group = self.kwargs.get("group")
+                is_opds_acquisition &= group in self.opds_acquisition_groups
+                if is_opds_acquisition and group == "a":
+                    pks = self.kwargs["pks"]
+                    is_opds_acquisition &= bool(pks and 0 not in pks)
+            self._is_opds_acquisition = is_opds_acquisition
+        return self._is_opds_acquisition
+
+    @property
+    def order_agg_func(self):
+        """Get the order aggregate function."""
+        if self._order_agg_func is None:
+            order_reverse = self.params.get("order_reverse")
+            self._order_agg_func = Max if order_reverse else Min
+        return self._order_agg_func
+
+    def _alias_sort_names(self, qs):
+        """Annotate sort_name."""
+        if self.order_key != "sort_name" and not (
+            qs.model is StoryArc and self.order_key == "story_arc_number"
+        ):
+            return qs
+        pks = self.kwargs.get("pks")
+        show = MappingProxyType(self.params["show"])  # type: ignore
+        # TODO too many annotations for order?
+        #   Move other annotations to card.
+        #   eager publisher for imprint of course
+        sort_name_annotations = self.get_sort_name_annotations(
+            qs.model, self.model_group, pks, show
+        )
+        if sort_name_annotations:
+            qs = qs.alias(**sort_name_annotations)
+            if qs.model is Comic:
+                self._comic_sort_names = tuple(sort_name_annotations.keys())
+        return qs
+
+    def _alias_filename(self, qs):
+        """Calculate filename from path in the db."""
+        if self.order_key != "filename":
+            return qs
+        if qs.model is Folder:
+            filename = F("name")
+        else:
+            prefix = "" if qs.model == Comic else self.rel_prefix
+            path_rel = prefix + "path"
+            filename = self.order_agg_func(
+                Right(
+                    path_rel,
+                    StrIndex(Reverse(F(path_rel)), Value(sep)) - 1,  # type: ignore
+                    output_field=CharField(),
+                )
+            )
+        return qs.alias(filename=filename)
+
+    def _alias_story_arc_number(self, qs):
+        if self.order_key != "story_arc_number":
+            return qs
+
+        # Get story_arc__pk
+        group = self.kwargs["group"]
+        pks = self.kwargs["pks"]
+        if group == STORY_ARC_GROUP and pks:
+            story_arc_pks = pks
+        else:
+            story_arc_pks = self.params.get("filters", {}).get(  # type: ignore
+                "story_arcs", ()
+            )
+
+        # If we have one annotate it.
+        if story_arc_pks:
+            rel = self.get_rel_prefix(qs.model) + "story_arc_numbers"
+            condition_rel = "pk" if qs.model is StoryArc else rel + "__story_arc"
+            condition = Q(**{f"{condition_rel}__in": story_arc_pks})
+            qs = qs.alias(
+                selected_story_arc_number=FilteredRelation(rel, condition=condition),
+            )
+            story_arc_number = self.order_agg_func("selected_story_arc_number__number")
+        else:
+            story_arc_number = NONE_INTEGERFIELD
+
+        return qs.alias(story_arc_number=story_arc_number)
+
+    def _annotate_page_count(self, qs):
+        """Hoist up total page_count of children."""
+        # Used for sorting and progress
+        if qs.model is Comic or (
+            self.order_key != "page_count"
+            and self.TARGET not in self._PAGE_COUNT_TARGETS
+        ):
+            return qs
+
+        rel = self.rel_prefix + "page_count"
+        page_count_sum = Sum(rel, distinct=True)
+        if self.TARGET == "browser":
+            qs = qs.alias(page_count=page_count_sum)
+        else:
+            qs = qs.annotate(page_count=page_count_sum)
+        return qs
+
+    def _annotate_bookmark_updated_at(self, qs):
+        if self.is_opds_acquisition or self.order_key == "bookmark_updated_at":
+            bmua_agg = self.get_max_bookmark_updated_at_aggregate(
+                qs.model, agg_func=self.order_agg_func
+            )
+            # This is used by annotate.bookmark to avoid a
+            # similar query.
+            self.bmua_is_max = self.order_agg_func is Max
+            qs = qs.annotate(bookmark_updated_at=bmua_agg)
+        # This is used by the serializer to compute mtime
+        return qs.annotate(bmua_is_max=Value(self.bmua_is_max))
+
+    def annotate_order_value(self, qs):
+        """Annotate a main key for sorting and browser card display."""
+        # Determine order func
+        if self.TARGET == "metadata":
+            return qs
+        if qs.model is Folder and self.order_key == "filename":
+            order_value = F("name")
+        elif qs.model is Comic or self.order_key in _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_agg_func if agg_func == Min else agg_func
+            field = self.rel_prefix + self.order_key
+            order_value = agg_func(field)
+
+        if self.TARGET == "browser":
+            qs = qs.annotate(order_value=order_value)
+        else:
+            qs = qs.alias(order_value=order_value)
+        return qs
+
+    def _annotate_search_scores(self, qs):
+        """Annotate Search Scores."""
+        if (
+            self.TARGET not in self._COVER_AND_CARD_TARGETS
+            or self.order_key != "search_score"
+        ):
+            return qs
+
+        # Rank is always the max of the relations, cannot aggregate?
+        # group by here fixes duplicates with story_arc, probably because it's a long relation
+        return qs.annotate(search_score=ComicFTSRank()).group_by("id")
+
+    def annotate_order_aggregates(self, qs):
+        """Annotate common aggregates between browser and metadata."""
+        qs = qs.annotate(ids=JsonGroupArray("id", distinct=True))
+        qs = self._annotate_search_scores(qs)
+        qs = self._alias_sort_names(qs)
+        qs = self._alias_filename(qs)
+        qs = self._alias_story_arc_number(qs)
+        qs = self._annotate_page_count(qs)
+        qs = self._annotate_bookmark_updated_at(qs)
+        if qs.model is not Comic:
+            # comic orders on indexed fields when it can
+            qs = self.annotate_order_value(qs)
+        return qs

codex/views/browser/breadcrumbs.py

@@ -2,18 +2,94 @@
 
 from contextlib import suppress
 from types import MappingProxyType
+from typing import TYPE_CHECKING
 
 from codex.logger.logging import get_logger
+from codex.models import (
+    BrowserGroupModel,
+    Comic,
+    Imprint,
+    Volume,
+)
+from codex.models.groups import Publisher
 from codex.views.browser.paginate import BrowserPaginateView
-from codex.views.const import FOLDER_GROUP, GROUP_NAME_MAP, GROUP_ORDER, STORY_ARC_GROUP
+from codex.views.const import (
+    FOLDER_GROUP,
+    GROUP_MODEL_MAP,
+    GROUP_NAME_MAP,
+    GROUP_ORDER,
+    STORY_ARC_GROUP,
+)
 from codex.views.util import Route
 
+if TYPE_CHECKING:
+    from codex.models.groups import Folder
+
 LOG = get_logger(__name__)
+_GROUP_INSTANCE_SELECT_RELATED: MappingProxyType[
+    type[BrowserGroupModel], tuple[str | None, ...]
+] = MappingProxyType(
+    {
+        Comic: ("series", "volume"),
+        Volume: ("series",),
+        Imprint: ("publisher",),
+    }
+)
 
 
 class BrowserBreadcrumbsView(BrowserPaginateView):
     """Browser breadcrumbs calculations."""
 
+    def __init__(self, *args, **kwargs):
+        """Set params for the type checker."""
+        super().__init__(*args, **kwargs)
+        self._group_instance: BrowserGroupModel | None | int = 0
+
+    def _get_group_query(self, model):
+        """Get the group query for the group instance."""
+        pks = self.kwargs.get("pks")
+        qs = model.objects.filter(pk__in=pks)
+        if select_related := _GROUP_INSTANCE_SELECT_RELATED.get(model):
+            qs = qs.select_related(*select_related)
+        order_by = "name" if model is Volume else "sort_name"
+        return qs.order_by(order_by)
+
+    def _handle_group_query_missing_model(self, model):
+        """Handle a missing model for the group instance."""
+        group = self.kwargs.get("group")
+        pks = self.kwargs.get("pks")
+        page = self.kwargs.get("page")
+        if group == "r" and not pks and page == 1:
+            group_query = model.objects.none()
+        else:
+            reason = f"{group}__in={pks} does not exist!"
+            settings_mask = {"breadcrumbs": []}
+            self.raise_redirect(
+                reason,
+                route_mask={"group": group},
+                settings_mask=settings_mask,
+            )
+        return group_query
+
+    @property
+    def group_instance(self) -> BrowserGroupModel | None:
+        """Memoize group instance for getting group names & counts."""
+        if self._group_instance == 0:
+            group = self.kwargs.get("group")
+            model = GROUP_MODEL_MAP[group]
+            pks = self.kwargs.get("pks")
+            if model and pks and 0 not in pks:
+                try:
+                    group_query = self._get_group_query(model)
+                except model.DoesNotExist:
+                    group_query = self._handle_group_query_missing_model(model)
+            else:
+                if not model:
+                    model = Publisher
+                group_query = model.objects.none()
+            self._group_instance = group_query.first()
+        return self._group_instance  # type: ignore
+
     def _init_breadcrumbs(self, valid_groups):
         """Load breadcrumbs and determine if they should be searched for a graft."""
         breadcrumbs: list[Route] = list(self.params.get("breadcrumbs", []))
@@ -27,7 +103,8 @@ class BrowserBreadcrumbsView(BrowserPaginateView):
         """Save the breadcrumbs to params."""
         params = dict(self.params)
         params["breadcrumbs"] = tuple(crumb.dict() for crumb in breadcrumbs)
-        self.params = MappingProxyType(params)
+        # HACK rewriting params
+        self._params = MappingProxyType(params)
 
     def _breadcrumbs_graft_or_create_story_arc(self) -> tuple[tuple[Route, ...], bool]:
         """Graft or create story_arc breadcrumbs."""
@@ -35,7 +112,7 @@ class BrowserBreadcrumbsView(BrowserPaginateView):
 
         pks = self.kwargs["pks"]
         page = self.kwargs["page"]
-        gi = self.group_instance  # type: ignore
+        gi = self.group_instance
         name = gi.name if gi else ""
         group_crumb = Route(STORY_ARC_GROUP, pks, page, name)
 
@@ -69,7 +146,7 @@ class BrowserBreadcrumbsView(BrowserPaginateView):
 
         pks = self.kwargs["pks"]
         page = self.kwargs["page"]
-        folder = self.group_instance  # type: ignore
+        folder: Folder | None = self.group_instance  # type: ignore
         name = folder.name if folder and pks else ""
         group_crumb = Route(FOLDER_GROUP, pks, page, name)
         new_breadcrumbs = []
@@ -91,11 +168,13 @@ class BrowserBreadcrumbsView(BrowserPaginateView):
             # parent next
             if not folder:
                 break
-            folder = folder.parent_folder
-            if folder:
-                group_crumb = Route(FOLDER_GROUP, (folder.pk,), 1, name=folder.name)
+            if folder := folder.parent_folder:
+                parent_pks = (folder.pk,)
+                parent_name = folder.name
             else:
-                group_crumb = Route(FOLDER_GROUP, (), 1, name="")
+                parent_pks = ()
+                parent_name = ""
+            group_crumb = Route(FOLDER_GROUP, parent_pks, 1, parent_name)
 
         breadcrumbs = new_breadcrumbs
 
@@ -103,16 +182,16 @@ class BrowserBreadcrumbsView(BrowserPaginateView):
 
     def _get_breadcrumbs_group_crumb(self, group):
         """Create the crumb for this group."""
-        gi = self.group_instance  # type: ignore
+        gi = self.group_instance
         if not gi:
             pks = ()
             page = 1
             name = ""
-        if group == self.kwargs["group"]:
+        elif group == self.kwargs["group"]:
             # create self crumb
             pks = self.kwargs["pks"]
             page = self.kwargs["page"]
-            name = gi.name if gi else ""
+            name = gi.name
         else:
             page = 1
             if (attr := GROUP_NAME_MAP.get(group)) and (