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

codex/views/browser/browser.py

@@ -20,6 +20,7 @@ from codex.models import (
     Library,
     Publisher,
     Series,
+    StoryArc,
     Timestamp,
     Volume,
 )
@@ -49,9 +50,11 @@ class BrowserView(BrowserAnnotationsView):
         Imprint: ("publisher",),
         Publisher: (None,),
         Folder: ("parent_folder",),
+        StoryArc: (None,),
     }
+    DEFAULT_ROUTE_NAME = "browser"
     _DEFAULT_ROUTE = {
-        "name": "browser",
+        "name": DEFAULT_ROUTE_NAME,
         "params": deepcopy(DEFAULTS["route"]),
     }
     _OPDS_M2M_RELS = (
@@ -59,7 +62,8 @@ class BrowserView(BrowserAnnotationsView):
         "genres",
         "locations",
         "series_groups",
-        "story_arcs",
+        "story_arc_numbers",
+        "story_arc_numbers__story_arc",
         "tags",
         "teams",
         "creators",
@@ -88,37 +92,16 @@ class BrowserView(BrowserAnnotationsView):
         return queryset.annotate(**group_names)
 
     def _add_annotations(self, queryset, model, search_scores):
-        """Annotations for display and sorting.
-
-        model is neccissary because this gets called twice by folder
-        view. once for folders, once for the comics.
-        """
-        is_model_comic = model == Comic
-        ##############################
-        # Annotate Common Aggregates #
-        ##############################
+        """Annotations for display and sorting."""
         queryset = self.annotate_common_aggregates(queryset, model, search_scores)
-        if not is_model_comic:
-            # EXTRA FILTER for empty group
-            queryset = queryset.filter(child_count__gt=0)
 
-        ##################
-        # Annotate Group #
-        ##################
+        # Annotate Group
         self.model_group = self._MODEL_GROUP_MAP[model]
         queryset = queryset.annotate(
             group=Value(self.model_group, CharField(max_length=1))
         )
-
-        #######################
-        # Sortable aggregates #
-        #######################
-        order_key = self.get_order_key()
-        order_func = self.get_aggregate_func(order_key, model)
-        queryset = queryset.annotate(order_value=order_func)
-
-        queryset = self._annotate_group_names(queryset, model)
-        return queryset
+        # Hoist Group Names
+        return self._annotate_group_names(queryset, model)
 
     def _get_model_group(self):
         """Get the group of the models to browse."""
@@ -127,7 +110,10 @@ class BrowserView(BrowserAnnotationsView):
         #   the child of the current nav group or 'c'
         group = self.kwargs["group"]
         if group == self.FOLDER_GROUP:
-            return self.FOLDER_GROUP
+            return group
+        if group == self.STORY_ARC_GROUP:
+            pk = self.kwargs["pk"]
+            return self.COMIC_GROUP if pk else group
         if group == self.valid_nav_groups[-1]:
             # special case for lowest valid group
             return self.COMIC_GROUP
@@ -141,35 +127,36 @@ class BrowserView(BrowserAnnotationsView):
         model_group = self._get_model_group()
         self.model = self.GROUP_MODEL_MAP[model_group]
 
-    def _get_queryset(self, object_filter, search_scores):
-        """Create queryset."""
-        # GROUP QS
-        if self.model != Comic:
-            group_filter = object_filter
-            group_qs = self.model.objects.filter(group_filter)
-            group_qs = self._add_annotations(group_qs, self.model, search_scores)
-            group_qs = self.get_order_by(self.model, group_qs)
+    def _get_group_queryset(self, object_filter, search_scores):
+        """Create group queryset."""
+        if self.model == Comic:
+            qs = self.model.objects.none()
         else:
-            group_qs = self.model.objects.none()
+            qs = self.model.objects.filter(object_filter)
+            qs = self._add_annotations(qs, self.model, search_scores)
+            qs = self.add_order_by(qs, self.model)
+        return qs
 
-        # BOOK QS
+    def _get_book_queryset(self, object_filter, search_scores):
+        """Create book queryset."""
         group = self.kwargs.get("group")
         if self.model == Comic or group == self.FOLDER_GROUP:
             if group == self.FOLDER_GROUP:
                 comic_object_filter, comic_search_scores = self.get_query_filters(
-                    True, False
+                    self.model, False
                 )
             else:
                 comic_object_filter = object_filter
                 comic_search_scores = search_scores
 
-            book_qs = Comic.objects.filter(comic_object_filter)
-            book_qs = self._add_annotations(book_qs, Comic, comic_search_scores)
-            book_qs = self.get_order_by(Comic, book_qs)
+            qs = Comic.objects.filter(comic_object_filter)
+            qs = self._add_annotations(qs, Comic, comic_search_scores)
+            qs = self.add_order_by(qs, Comic)
+            if limit := self.params.get("limit"):
+                qs = qs[:limit]
         else:
-            book_qs = Comic.objects.none()
-
-        return group_qs, book_qs
+            qs = Comic.objects.none()
+        return qs
 
     def _get_folder_up_route(self):
         """Get out parent's pk."""
@@ -186,11 +173,17 @@ class BrowserView(BrowserAnnotationsView):
 
         return up_group, up_pk
 
+    def _get_story_arc_up_route(self):
+        """Get one level hierarchy."""
+        up_group = self.STORY_ARC_GROUP
+        up_group = 0 if self.group_instance else None
+        return self.STORY_ARC_GROUP, up_group
+
     def _set_group_instance(self):
         """Create group_class instance."""
         pk = self.kwargs.get("pk")
         self.group_instance: Optional[
-            Union[Folder, Publisher, Imprint, Series, Volume]
+            Union[Folder, Publisher, Imprint, Series, Volume, StoryArc]
         ] = None
         if not pk:
             return
@@ -322,7 +315,7 @@ class BrowserView(BrowserAnnotationsView):
             )
 
         if book_qs.count():
-            book_max_obj_per_page = self.MAX_OBJ_PER_PAGE - group_qs.count()
+            book_max_obj_per_page = max(0, self.MAX_OBJ_PER_PAGE - group_qs.count())
             page_counts = (num_pages, total_count, Comic)
             group_qs, num_pages, total_count = self._paginate_section(
                 group_qs, book_max_obj_per_page, page_counts
@@ -333,11 +326,11 @@ class BrowserView(BrowserAnnotationsView):
     def get_object(self):
         """Validate settings and get the querysets."""
         self._set_browse_model()
+        self.set_rel_prefix(self.model)
         self._set_group_instance()  # Placed up here to invalidate earlier
         # Create the main query with the filters
-        is_model_comic = self.model == Comic
         try:
-            object_filter, search_scores = self.get_query_filters(is_model_comic, False)
+            object_filter, search_scores = self.get_query_filters(self.model, False)
         except Folder.DoesNotExist:
             pk = self.kwargs.get("pk")
             self._raise_redirect(
@@ -348,7 +341,8 @@ class BrowserView(BrowserAnnotationsView):
             search_scores = {}
         group = self.kwargs.get("group")
 
-        group_qs, book_qs = self._get_queryset(object_filter, search_scores)
+        group_qs = self._get_group_queryset(object_filter, search_scores)
+        book_qs = self._get_book_queryset(object_filter, search_scores)
 
         # Paginate
         group_qs, book_qs, num_pages, total_count = self._paginate(group_qs, book_qs)
@@ -356,6 +350,8 @@ class BrowserView(BrowserAnnotationsView):
         # get additional context
         if group == self.FOLDER_GROUP:
             up_group, up_pk = self._get_folder_up_route()
+        elif group == self.STORY_ARC_GROUP:
+            up_group, up_pk = self._get_story_arc_up_route()
         else:
             up_group, up_pk = self._get_browse_up_route()
         browser_page_title = self._get_browser_page_title()
@@ -459,9 +455,7 @@ class BrowserView(BrowserAnnotationsView):
 
         top_group = self.params["top_group"]
         if top_group != self.FOLDER_GROUP:
-            reason = f"top_group {top_group} doesn't match route {self.FOLDER_GROUP}"
-            settings_mask = {"top_group": self.FOLDER_GROUP}
-            self._raise_redirect({"group": self.FOLDER_GROUP}, reason, settings_mask)
+            self.params["top_group"] = self.FOLDER_GROUP
 
         # set valid folder nav groups
         self.valid_nav_groups = (self.FOLDER_GROUP,)
@@ -500,12 +494,25 @@ class BrowserView(BrowserAnnotationsView):
             reason = f"Redirect r with {pk=} to pk 0"
             self._raise_redirect({"pk": 0}, reason)
 
+    def _validate_story_arc_settings(self):
+        """Validate story arc settings."""
+        top_group = self.params["top_group"]
+        if top_group != self.STORY_ARC_GROUP:
+            self.params["top_group"] = self.STORY_ARC_GROUP
+
+    def _set_route_param(self):
+        """Set the route param."""
+        group = self.kwargs.get("group", "r")
+        pk = self.kwargs.get("pk", 0)
+        page = self.kwargs.get("page", 1)
+        self.params["route"] = {"group": group, "pk": pk, "page": page}
+
     def validate_settings(self):
         """Validate group and top group settings."""
         group = self.kwargs.get("group")
-        order_key = self.get_order_key()
+        self.set_order_key()
         enable_folder_view = False
-        if group == self.FOLDER_GROUP or order_key == "path":
+        if group == self.FOLDER_GROUP or self.order_key == "path":
             key = AdminFlag.FlagChoices.FOLDER_VIEW.value
             try:
                 enable_folder_view = AdminFlag.objects.only("on").get(key=key).on
@@ -515,11 +522,13 @@ class BrowserView(BrowserAnnotationsView):
 
         if group == self.FOLDER_GROUP:
             self._validate_folder_settings(enable_folder_view)
+        elif group == self.STORY_ARC_GROUP:
+            self._validate_story_arc_settings()
         else:
             self._validate_browser_group_settings()
 
         # Validate path sort
-        if order_key == "path" and not enable_folder_view:
+        if self.order_key == "path" and not enable_folder_view:
             pk = self.kwargs("pk")
             page = self.kwargs("page")
             route_changes = {"group": group, "pk": pk, "page": page}
@@ -532,6 +541,7 @@ class BrowserView(BrowserAnnotationsView):
         """Get browser settings."""
         self.parse_params()
         self.validate_settings()
+        self._set_route_param()
         data = self.get_object()
         serializer = self.get_serializer(data)
         self.save_params_to_session(self.params)

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