codex 1.6.19__py3-none-any.whl → 1.7.0__py3-none-any.whl

codex/views/bookmark.py

@@ -1,180 +1,41 @@
 """Bookmark views."""
 
-from django.db.models.expressions import F
-from django.db.models.functions import Now
 from drf_spectacular.utils import extend_schema
 from rest_framework.response import Response
 
-from codex.librarian.mp_queue import LIBRARIAN_QUEUE
-from codex.librarian.notifier.tasks import NotifierTask
+from codex.librarian.bookmark.update import BookmarkUpdate
 from codex.logger.logging import get_logger
-from codex.models import Bookmark, Comic
 from codex.serializers.models.bookmark import (
     BookmarkFinishedSerializer,
     BookmarkSerializer,
 )
 from codex.views.auth import (
+    AuthFilterAPIView,
     AuthFilterGenericAPIView,
 )
 from codex.views.const import FILTER_ONLY_GROUP_RELATION
 
 LOG = get_logger(__name__)
-VERTICAL_READING_DIRECTIONS = frozenset({"ttb", "btt"})
-_BOOKMARK_UPDATE_FIELDS = frozenset(
-    {
-        "page",
-        "finished",
-        "fit_to",
-        "two_pages",
-        "reading_direction",
-    }
-)
-_COMIC_ONLY_FIELDS = ("pk", "page_count")
-
-
-class BookmarkFilterBaseView(AuthFilterGenericAPIView):
-    """API Views that get Bookmarks."""
 
-    def get_bookmark_search_kwargs(self, comic_filter=None):
-        """Get the search kwargs for a user's authentication state."""
-        search_kwargs = {}
 
-        if comic_filter:
-            for key, value in comic_filter.items():
-                search_kwargs[f"comic__{key}"] = value
+class BookmarkBaseView(AuthFilterAPIView):
+    """Base class for Bookmark Views."""
 
+    def get_bookmark_auth_filter(self):
+        """Filter only the user's bookmarks."""
         if self.request.user.is_authenticated:
-            search_kwargs["user"] = self.request.user
+            key = "user_id"
+            value = self.request.user.pk
         else:
             if not self.request.session or not self.request.session.session_key:
                 LOG.debug("no session, make one")
                 self.request.session.save()
-            search_kwargs["session_id"] = self.request.session.session_key
-        return search_kwargs
-
-
-class BookmarkBaseView(BookmarkFilterBaseView):
-    """Bookmark Updater."""
-
-    @staticmethod
-    def _update_bookmarks_validate_page(bm, updates):
-        """Force bookmark page into valid range."""
-        page = updates.get("page")
-        if page is None:
-            return
-        max_page = bm.page_count + 1
-        page = max(min(page, max_page), 0)
-        if page == max_page:
-            # Auto finish on bookmark last page
-            bm.finished = True
-        updates["page"] = page
-
-    @staticmethod
-    def _update_bookmarks_validate_two_pages(bm, updates):
-        """Force vertical view to not use two pages."""
-        rd = updates.get("reading_direction")
-        if (
-            bm.two_pages
-            and rd in VERTICAL_READING_DIRECTIONS
-            or bm.reading_direction in VERTICAL_READING_DIRECTIONS
-        ):
-            updates["two_pages"] = None
-
-    def notify_library_changed(self):
-        """Notify one user that their library changed."""
-        if user := self.request.user:
-            uid = user.id  # type: ignore
-        else:
-            uid = self.request.session.session_key
-        group = f"user_{uid}"
-        task = NotifierTask("LIBRARY_CHANGED", group)
-        LIBRARIAN_QUEUE.put(task)
+            key = "session_id"
+            value = self.request.session.session_key
+        return {key: value}
 
-    def _update_bookmarks(self, search_kwargs, updates):
-        """Update existing bookmarks."""
-        count = 0
-        finished = False
-        if not updates:
-            return count, finished
-        group_acl_filter = self.get_group_acl_filter(Bookmark)
-        update_fields = set(updates.keys()) & _BOOKMARK_UPDATE_FIELDS
-        update_fields.add("updated_at")
-        only_fields = (*update_fields, "pk")
-        existing_bookmarks = Bookmark.objects.filter(group_acl_filter).filter(
-            **search_kwargs
-        )
-        if updates.get("page") is not None:
-            existing_bookmarks = existing_bookmarks.annotate(
-                page_count=F("comic__page_count")
-            )
-        existing_bookmarks = existing_bookmarks.only(*only_fields)
-        update_bookmarks = []
-        for bm in existing_bookmarks:
-            self._update_bookmarks_validate_page(bm, updates)
-            self._update_bookmarks_validate_two_pages(bm, updates)
-            for key, value in updates.items():
-                setattr(bm, key, value)
-            bm.updated_at = Now()
-            update_bookmarks.append(bm)
-        count = len(update_bookmarks)
-        if count:
-            Bookmark.objects.bulk_update(update_bookmarks, tuple(update_fields))
-        return count
 
-    @staticmethod
-    def _create_bookmarks_validate_two_pages(updates):
-        """Force vertical view to not use two pages."""
-        if (
-            updates.get("two_pages")
-            and updates.get("reading_direction") in VERTICAL_READING_DIRECTIONS
-        ):
-            updates.pop("two_pages", None)
-
-    def _create_bookmarks(self, comic_filter, search_kwargs, updates):
-        """Create new bookmarks for comics that don't exist yet."""
-        count = 0
-        self._create_bookmarks_validate_two_pages(updates)
-        if not updates:
-            return count
-        create_bookmarks = []
-        group_acl_filter = self.get_group_acl_filter(Comic)
-        exclude = {}
-        for key, value in search_kwargs.items():
-            exclude["bookmark__" + key] = value
-        create_bookmark_comics = (
-            Comic.objects.filter(group_acl_filter)
-            .filter(**comic_filter)
-            .exclude(**exclude)
-            .only(*_COMIC_ONLY_FIELDS)
-        )
-        for comic in create_bookmark_comics:
-            defaults = {"comic": comic}
-            defaults.update(updates)
-            for key, value in search_kwargs.items():
-                if not key.startswith("comic"):
-                    defaults[key] = value
-
-            bm = Bookmark(**defaults)
-            create_bookmarks.append(bm)
-        count = len(create_bookmarks)
-        if count:
-            Bookmark.objects.bulk_create(
-                create_bookmarks,
-                update_fields=tuple(_BOOKMARK_UPDATE_FIELDS),
-                unique_fields=Bookmark._meta.unique_together[0],  # type: ignore
-            )
-        return count
-
-    def update_bookmarks(self, updates, comic_filter):
-        """Update a user bookmark."""
-        search_kwargs = self.get_bookmark_search_kwargs(comic_filter)
-        count = self._update_bookmarks(search_kwargs, updates)
-        count = +self._create_bookmarks(comic_filter, search_kwargs, updates)
-        if count:
-            self.notify_library_changed()
-
-
-class BookmarkView(BookmarkBaseView):
+class BookmarkView(AuthFilterGenericAPIView, BookmarkBaseView, BookmarkUpdate):
     """User Bookmark View."""
 
     serializer_class = BookmarkSerializer
@@ -198,10 +59,12 @@ class BookmarkView(BookmarkBaseView):
         """Update bookmarks recursively."""
         updates = self._parse_params()
 
+        auth_filter = self.get_bookmark_auth_filter()
+
         group = self.kwargs.get("group")
-        pks = self.kwargs.get("pks")
         rel = FILTER_ONLY_GROUP_RELATION[group] + "__in"
+        pks = self.kwargs.get("pks")
         comic_filter = {rel: pks}
 
-        self.update_bookmarks(updates, comic_filter)
+        self.update_bookmarks(auth_filter, comic_filter, updates)
         return Response()

codex/views/browser/annotate/__init__.py

@@ -0,0 +1 @@
+"""Browser annotation methods."""

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