codex 1.4.0a1__py3-none-any.whl → 1.4.1__py3-none-any.whl

codex/views/browser/browser_annotations.py

@@ -1,10 +1,15 @@
 """Base view for metadata annotations."""
+from os.path import sep
+
 from django.db.models import (
     BooleanField,
     Case,
+    CharField,
     Count,
     DateTimeField,
     F,
+    FilteredRelation,
+    Min,
     OuterRef,
     Q,
     Subquery,
@@ -13,10 +18,9 @@ from django.db.models import (
     When,
 )
 from django.db.models.fields import PositiveSmallIntegerField
-from django.db.models.functions import Least
+from django.db.models.functions import Least, Lower, Reverse, Right, StrIndex, Substr
 
-from codex.models import Comic, Folder, Imprint, Publisher, Series, Volume
-from codex.views.browser.base import BrowserBaseView
+from codex.models import Comic
 from codex.views.browser.browser_order_by import BrowserOrderByView
 
 
@@ -24,31 +28,36 @@ class BrowserAnnotationsView(BrowserOrderByView):
     """Base class for views that need special metadata annotations."""
 
     _ONE_INTEGERFIELD = Value(1, PositiveSmallIntegerField())
-    # used by browser & metadata
-    GROUP_MODEL_MAP = {
-        BrowserBaseView.ROOT_GROUP: None,
-        "p": Publisher,
-        "i": Imprint,
-        "s": Series,
-        "v": Volume,
-        BrowserBaseView.COMIC_GROUP: Comic,
-        BrowserBaseView.FOLDER_GROUP: Folder,
-    }
+    _NONE_INTEGERFIELD = Value(None, PositiveSmallIntegerField())
     _NONE_DATETIMEFIELD = Value(None, DateTimeField())
+    _ARTICLES = frozenset(
+        ("a", "an", "the")  # en    # noqa RUF005
+        + ("un", "unos", "unas", "el", "los", "la", "las")  # es
+        + ("un", "une", "le", "les", "la", "les", "l'")  # fr
+        + ("o", "a", "os")  # pt
+        # pt "as" conflicts with English
+        + ("der", "dem", "des", "das")  # de
+        # de: "den & die conflict with English
+        + ("il", "lo", "gli", "la", "le", "l'")  # it
+        # it: "i" conflicts with English
+        + ("de", "het", "een")  # nl
+        + ("en", "ett")  # sw
+        + ("en", "ei", "et")  # no
+        + ("en", "et")  # da
+        + ("el", "la", "els", "les", "un", "una", "uns", "unes", "na")  # ct
+    )
 
     is_opds_1_acquisition = False
 
-    def _annotate_search_score(self, queryset, is_model_comic, search_scores):
+    def _annotate_search_score(self, queryset, search_scores):
         """Annotate the search score for ordering by search score."""
-        order_key = self.params.get("order_by")
-        if order_key != "search_score":
+        if self.order_key != "search_score":
             return queryset
-        prefix = "comic__" if not is_model_comic else ""
         whens = []
         for pk, score in search_scores.items():
-            when = {prefix + "pk": pk, "then": score}
+            when = {self.rel_prefix + "pk": pk, "then": score}
             whens.append(When(**when))
-        annotate = {prefix + "search_score": Case(*whens, default=0.0)}
+        annotate = {self.rel_prefix + "search_score": Case(*whens, default=0.0)}
         return queryset.annotate(**annotate)
 
     def _annotate_cover_pk(self, queryset, model):
@@ -60,28 +69,134 @@ class BrowserAnnotationsView(BrowserOrderByView):
         else:
             # This creates two subqueries. It would be better condensed into one.
             # but there's no way to annotate an object or multiple values.
-            qs = queryset.filter(pk=OuterRef("pk"))
-            cover_comics = self.get_order_by(Comic, qs, for_cover_pk=True)
-            cover_pk = Subquery(cover_comics.values("comic__pk")[:1])
+            cover_qs = queryset.filter(pk=OuterRef("pk"))
+            cover_qs = self.add_order_by(cover_qs, model)
+            cover_pk = Subquery(cover_qs.values(self.rel_prefix + "pk")[:1])
         return queryset.annotate(cover_pk=cover_pk)
 
-    def _annotate_page_count(self, qs):
+    def _annotate_page_count(self, qs, model):
         """Hoist up total page_count of children."""
         # Used for sorting and progress
-        page_count_sum = Sum("comic__page_count", distinct=True)
+        if model == Comic:
+            return qs
+
+        page_count_sum = Sum(self.rel_prefix + "page_count", distinct=True)
         return qs.annotate(page_count=page_count_sum)
 
-    def _annotate_bookmarks(self, qs, is_model_comic):
-        """Hoist up bookmark annoations."""
-        bm_rel = self.get_bm_rel(is_model_comic)
-        bm_filter = self._get_my_bookmark_filter(bm_rel)
+    def _annotate_child_count(self, qs, model):
+        """Annotate Child Count."""
+        self.kwargs.get("group")
+        if model == Comic:
+            child_count_sum = self._ONE_INTEGERFIELD
+        else:
+            child_count_sum = Count(self.rel_prefix + "pk", distinct=True)
+        qs = qs.annotate(child_count=child_count_sum)
+        if model != Comic:
+            # XXX Extra filter for empty groups
+            qs = qs.filter(child_count__gt=0)
+        return qs
+
+    def _annotate_bookmark_updated_at(self, qs, bm_rel, bm_filter):
+        """Annotate bookmark_updated_at."""
+        if not self.is_opds_1_acquisition and self.order_key != "bookmark_updated_at":
+            return qs
+
+        updated_at_rel = f"{bm_rel}__updated_at"
+        bookmark_updated_at_aggregate = Min(
+            updated_at_rel,
+            default=self._NONE_DATETIMEFIELD,
+            filter=bm_filter,
+        )
+        return qs.annotate(bookmark_updated_at=bookmark_updated_at_aggregate)
+
+    def _annotate_sort_name(self, queryset, model):
+        """Sort groups by name ignoring articles."""
+        if self.order_key != "sort_name":
+            return queryset
+
+        if self.kwargs.get("group") == self.FOLDER_GROUP and model == Comic:
+            # File View Filename
+            queryset = queryset.annotate(
+                sort_name=Right(
+                    "path",
+                    StrIndex(Reverse(F("path")), Value(sep)) - 1,  # type: ignore
+                    output_field=CharField(),
+                )
+            )
+            return queryset
+
+        ##################################################
+        # Otherwise Remove articles from the browse name #
+        ##################################################
+
+        # first_space_index
+        first_field = model.ORDERING[0]
+        queryset = queryset.annotate(
+            first_space_index=StrIndex(first_field, Value(" "))
+        )
+
+        # lowercase_first_word
+        lowercase_first_word = Lower(
+            Substr(first_field, 1, length=(F("first_space_index") - 1))  # type: ignore
+        )
+        queryset = queryset.annotate(
+            lowercase_first_word=Case(
+                When(Q(first_space_index__gt=0), then=lowercase_first_word)
+            ),
+            default=Value(""),
+        )
 
+        # sort_name
+        return queryset.annotate(
+            sort_name=Case(
+                When(
+                    lowercase_first_word__in=self._ARTICLES,
+                    then=Substr(
+                        first_field, F("first_space_index") + 1  # type: ignore
+                    ),
+                ),
+                default=first_field,
+            )
+        )
+
+    def _annotate_story_arc_number(self, qs):
+        if self.order_key != "story_arc_number":
+            return qs
+
+        # Get story_arc__pk
+        group = self.kwargs["group"]
+        pk = self.kwargs["pk"]
+        if group == self.STORY_ARC_GROUP and pk:
+            story_arc_pk = pk
+        elif story_arc_pks := self.params.get("filters", {}).get("story_arcs", []):
+            story_arc_pk = story_arc_pks[0]
+        else:
+            story_arc_pk = None
+
+        # If we have one annotate it.
+        if story_arc_pk:
+            san_rel = self.rel_prefix + "story_arc_numbers"
+            rel = f"{san_rel}"
+            condition = Q(**{f"{san_rel}__story_arc": story_arc_pk})
+            qs = qs.annotate(
+                selected_story_arc_number=FilteredRelation(rel, condition=condition),
+                story_arc_number=F("selected_story_arc_number__number"),
+            )
+        else:
+            qs = qs.annotate(story_arc_number=self._NONE_INTEGERFIELD)
+        return qs
+
+    def _annotate_order_value(self, qs, model):
+        """Annotate a main key for sorting."""
+        order_func = self.get_order_value(model)
+        return qs.annotate(order_value=order_func)
+
+    def _annotate_bookmarks(self, qs, model, bm_rel, bm_filter):
+        """Hoist up bookmark annoations."""
         page_rel = f"{bm_rel}__page"
         finished_rel = f"{bm_rel}__finished"
-        updated_at_rel = f"{bm_rel}__updated_at"
-        bookmark_updated_at = None
 
-        if is_model_comic:
+        if model == Comic:
             # Hoist up the bookmark and finished states
             bookmark_page = Sum(
                 page_rel,
@@ -95,14 +210,12 @@ class BrowserAnnotationsView(BrowserOrderByView):
                 filter=bm_filter,
                 output_field=BooleanField(),
             )
-            if self.is_opds_1_acquisition:
-                bookmark_updated_at = F(updated_at_rel)
         else:
             # Aggregate bookmark and finished states
             bookmark_page = Sum(
                 Case(
                     When(**{bm_rel: None}, then=0),
-                    When(**{finished_rel: True}, then="comic__page_count"),
+                    When(**{finished_rel: True}, then=f"{self.rel_prefix}page_count"),
                     default=page_rel,
                     output_field=PositiveSmallIntegerField(),
                 ),
@@ -130,16 +243,10 @@ class BrowserAnnotationsView(BrowserOrderByView):
                 output_field=BooleanField(),
             )
 
-        qs = qs.annotate(
+        return qs.annotate(
             page=bookmark_page,
             finished=finished_aggregate,
         )
-        if bookmark_updated_at:
-            qs = qs.annotate(
-                bookmark_updated_at=bookmark_updated_at,
-            )
-
-        return qs
 
     @staticmethod
     def _annotate_progress(queryset):
@@ -154,15 +261,17 @@ class BrowserAnnotationsView(BrowserOrderByView):
 
     def annotate_common_aggregates(self, qs, model, search_scores):
         """Annotate common aggregates between browser and metadata."""
-        is_model_comic = model == Comic
-        qs = self._annotate_search_score(qs, is_model_comic, search_scores)
+        qs = self._annotate_search_score(qs, search_scores)
+        qs = self._annotate_child_count(qs, model)
+        qs = self._annotate_page_count(qs, model)
+        bm_rel = self.get_bm_rel(model)
+        bm_filter = self._get_my_bookmark_filter(bm_rel)
+        qs = self._annotate_bookmark_updated_at(qs, bm_rel, bm_filter)
+        qs = self._annotate_sort_name(qs, model)
+        qs = self._annotate_story_arc_number(qs)
+        qs = self._annotate_order_value(qs, model)
+        # cover depends on the above annotations for order-by
         qs = self._annotate_cover_pk(qs, model)
-        if is_model_comic:
-            child_count_sum = self._ONE_INTEGERFIELD
-        else:
-            qs = self._annotate_page_count(qs)
-            child_count_sum = Count("comic__pk", distinct=True)
-        qs = qs.annotate(child_count=child_count_sum)
-        qs = self._annotate_bookmarks(qs, is_model_comic)
+        qs = self._annotate_bookmarks(qs, model, bm_rel, bm_filter)
         qs = self._annotate_progress(qs)
         return qs

codex/views/browser/browser_order_by.py

@@ -1,10 +1,10 @@
 """Base view for ordering the query."""
 from os import sep
 
-from django.db.models import Avg, Case, CharField, F, Max, Min, Q, Sum, Value, When
-from django.db.models.functions import Lower, Reverse, Right, StrIndex, Substr
+from django.db.models import Avg, F, Max, Min, Sum, Value
+from django.db.models.functions import Reverse, Right, StrIndex
 
-from codex.models import Comic, Folder
+from codex.models import Comic, Folder, StoryArc
 from codex.views.browser.base import BrowserBaseView
 
 
@@ -22,33 +22,18 @@ class BrowserOrderByView(BrowserBaseView):
         "size": Sum,
         "updated_at": Min,
         "search_score": Min,
+        "story_arc_number": Min,
     }
     _SEP_VALUE = Value(sep)
-    _ARTICLES = frozenset(
-        ("a", "an", "the")  # en
-        + ("un", "unos", "unas", "el", "los", "la", "las")  # es
-        + ("un", "une", "le", "les", "la", "les", "l'")  # fr
-        + ("o", "a", "os")  # pt
-        # pt "as" conflicts with English
-        + ("der", "dem", "des", "das")  # de
-        # de: "den & die conflict with English
-        + ("il", "lo", "gli", "la", "le", "l'")  # it
-        # it: "i" conflicts with English
-        + ("de", "het", "een")  # nl
-        + ("en", "ett")  # sw
-        + ("en", "ei", "et")  # no
-        + ("en", "et")  # da
-        + ("el", "la", "els", "les", "un", "una", "uns", "unes", "na")  # ct
-    )
-    NONE_CHARFIELD = Value(None, CharField())
+    _ANNOTATED_ORDER_FIELDS = frozenset(("sort_name", "bookmark_updated_at"))
 
-    def get_order_key(self):
+    def set_order_key(self):
         """Get the default order key for the view."""
         order_key = self.params.get("order_by")
         if not order_key:
             group = self.kwargs.get("group")
             order_key = "path" if group == self.FOLDER_GROUP else "sort_name"
-        return order_key
+        self.order_key = order_key
 
     @classmethod
     def _get_path_query_func(cls, field):
@@ -57,97 +42,56 @@ class BrowserOrderByView(BrowserBaseView):
             field, StrIndex(Reverse(field), cls._SEP_VALUE) - 1  # type: ignore
         )
 
-    def get_aggregate_func(self, order_key, model):
-        """Get a complete function for aggregating an attribute."""
-        field = None if order_key == "sort_name" or not order_key else order_key
+    def get_aggregate_func(self, model, field):
+        """Order by aggregate."""
+        # get agg_func
+        agg_func = self._ORDER_AGGREGATE_FUNCS[field]
+        if agg_func == Min and self.params.get("order_reverse"):
+            agg_func = Max
+
+        # get full_field
+        self.kwargs.get("group")
+        if model == StoryArc and field == "story_arc_number":
+            full_field = "storyarcnumber__number"
+        else:
+            if self.order_key == "story_arc_number":
+                field = "story_arc_numbers__number"
+            full_field = self.rel_prefix + field
+        if field == "path":
+            full_field = self._get_path_query_func(full_field)
+
+        return agg_func(full_field)
 
+    def get_order_value(self, model):
+        """Get a complete function for aggregating an attribute."""
         # Determine order func
-        if not field:
-            # use default sorting.
-            func = self.NONE_CHARFIELD
-        elif field == "path" and model in (Comic, Folder):
+        if self.order_key == "path" and model in (Comic, Folder):
             # special path sorting.
-            func = self._get_path_query_func(field)
-        elif model == Comic:
+            func = self._get_path_query_func(self.order_key)
+        elif model == Comic or self.order_key in self._ANNOTATED_ORDER_FIELDS:
             # agg_none uses group fields not comic fields.
-            func = F(field)
+            func = F(self.order_key)
         else:
-            # order by aggregate.
-
-            # get agg_func
-            agg_func = self._ORDER_AGGREGATE_FUNCS[field]
-            if agg_func == Min and self.params.get("order_reverse"):
-                agg_func = Max
-
-            # get full_field
-            full_field = "comic__" + field
-            if field == "path":
-                full_field = self._get_path_query_func(full_field)
-
-            func = agg_func(full_field)
+            func = self.get_aggregate_func(model, self.order_key)
         return func
 
-    @classmethod
-    def _order_without_articles(cls, queryset, model):
-        """Sort groups by name ignoring articles."""
-        # first_space_index
-        first_field = model.ORDERING[0]
-        queryset = queryset.annotate(
-            first_space_index=StrIndex(first_field, Value(" "))
-        )
-
-        # lowercase_first_word
-        lowercase_first_word = Lower(
-            Substr(first_field, 1, length=(F("first_space_index") - 1))  # type: ignore
-        )
-        queryset = queryset.annotate(
-            lowercase_first_word=Case(
-                When(Q(first_space_index__gt=0), then=lowercase_first_word)
-            ),
-            default=Value(""),
-        )
-
-        # sort_name
-        queryset = queryset.annotate(
-            sort_name=Case(
-                When(
-                    lowercase_first_word__in=cls._ARTICLES,
-                    then=Substr(
-                        first_field, F("first_space_index") + 1  # type: ignore
-                    ),
-                ),
-                default=first_field,
-            )
-        )
-
-        # final ordering
-        ordering = ("sort_name", *model.ORDERING[1:])
-        return queryset, ordering
-
-    def get_order_by(self, model, queryset, for_cover_pk=False):
+    def add_order_by(self, queryset, model):
         """Create the order_by list."""
-        # order_fields
-        comic_rel = ""
-        order_key = self.get_order_key()
-        if for_cover_pk:
-            comic_rel = "comic__"
-            ordering = []
-            if order_key and order_key != "sort_name":
-                ordering += [order_key]
-            ordering += [*Comic.ORDERING]
-        elif order_key == "sort_name" or not order_key:
-            group = self.kwargs.get("group")
-            if group != self.FOLDER_GROUP:
-                # special annotations for ordering in browser mode
-                queryset, ordering = self._order_without_articles(queryset, model)
-            else:
-                ordering = model.ORDERING
+        prefix = ""
+        if self.params.get("order_reverse"):
+            prefix += "-"
+
+        if self.order_key == "sort_name":
+            order_fields = ("order_value", *model.ORDERING[1:])
+        elif self.order_key == "bookmark_updated_at":
+            order_fields = ("order_value", "updated_at", "created_at", "pk")
+        elif self.order_key == "story_arc_number" and model == Comic:
+            order_fields = ("order_value", "date", *model.ORDERING)
         else:
-            # Use annotated order_value
-            ordering = ("order_value", *model.ORDERING)
+            order_fields = ("order_value", *model.ORDERING)
+
+        order_by = []
+        for field in order_fields:
+            order_by.append(prefix + field)
 
-        # add prefixes to all order_by fields
-        neg_prefix = "-" if self.params.get("order_reverse") else ""
-        prefix = neg_prefix + comic_rel
-        ordering = (prefix + field for field in ordering)
-        return queryset.order_by(*ordering)
+        return queryset.order_by(*order_by)