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

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,95 +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, ordering):
-        """Sort by name ignoring articles."""
-        first_field = ordering[0]
-        queryset = queryset.annotate(
-            first_space_index=StrIndex(first_field, Value(" "))
-        )
-
-        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(""),
-        )
-
-        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,
-            )
-        )
-        ordering = ("sort_name", *ordering[1:])
-        return queryset, ordering
-
-    def get_order_by(self, model, queryset, for_cover_pk=False):
-        """Create the order_by list.
-
-        Order on pk to give duplicates a consistent position.
-        """
-        # order_prefix
-        prefix = "-" if self.params.get("order_reverse") else ""
-
-        # order_fields
-        order_key = self.get_order_key()
-        if for_cover_pk:
-            prefix += "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:
-            ordering = model.ORDERING
-            group = self.kwargs.get("group")
-            if group != self.FOLDER_GROUP:
-                # Can't annotate after union
-                queryset, ordering = self._order_without_articles(queryset, ordering)
+    def add_order_by(self, queryset, model):
+        """Create the order_by list."""
+        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)
 
-        # order_by
-        # add prefixes to all order_by fields
-        ordering = (prefix + field for field in ordering)
-        return queryset.order_by(*ordering)
+        return queryset.order_by(*order_by)

codex/views/browser/choices.py

@@ -1,11 +1,21 @@
 """View for marking comics read and unread."""
 import pycountry
 from caseconverter import snakecase
+from django.db.models import QuerySet
 from drf_spectacular.utils import extend_schema
 from rest_framework.response import Response
 
 from codex.logger.logging import get_logger
-from codex.models import Comic, CreatorPerson
+from codex.models import (
+    Comic,
+    CreatorPerson,
+    Folder,
+    Imprint,
+    Publisher,
+    Series,
+    StoryArc,
+    Volume,
+)
 from codex.serializers.browser import (
     BrowserChoicesSerializer,
     BrowserFilterChoicesSerializer,
@@ -22,23 +32,37 @@ class BrowserChoicesViewBase(BrowserBaseView):
 
     permission_classes = [IsAuthenticatedOrEnabledNonUsers]
 
-    CREATORS_PERSON_REL = "creators__person"
-    NULL_NAMED_ROW = {"pk": -1, "name": "_none_"}
+    _CREATORS_PERSON_REL = "creators__person"
+    _STORY_ARC_REL = "story_arc_numbers__story_arc"
+    _NULL_NAMED_ROW = {"pk": -1, "name": "_none_"}
+    _BACK_REL_MAP = {CreatorPerson: "creator__", StoryArc: "storyarcnumber__"}
+    _REL_MAP = {
+        Publisher: "publisher",
+        Imprint: "imprint",
+        Series: "series",
+        Volume: "volume",
+        Comic: "pk",
+        Folder: "parent_folder",
+        StoryArc: "story_arc_numbers__story_arc",
+    }
 
     @staticmethod
-    def get_field_choices_query(field_name, comic_qs):
+    def get_field_choices_query(comic_qs, field_name):
         """Get distinct values for the field."""
-        return comic_qs.values_list(field_name, flat=True).distinct()
+        return (
+            comic_qs.exclude(**{field_name: None})
+            .values_list(field_name, flat=True)
+            .distinct()
+        )
 
-    @classmethod
-    def get_m2m_field_query(cls, rel, comic_qs, model):
+    def get_m2m_field_query(self, model, comic_qs: QuerySet):
         """Get distinct m2m value objects for the relation."""
-        comic_rel = "creator__comic" if rel == cls.CREATORS_PERSON_REL else "comic"
+        back_rel = self._BACK_REL_MAP.get(model, "")
+        back_rel += "comic__"
+        back_rel += self._REL_MAP[self.model]
+        back_rel += "__in"
         return (
-            model.objects.filter(**{f"{comic_rel}__in": comic_qs})
-            .prefetch_related(comic_rel)
-            .values("pk", "name")
-            .distinct()
+            model.objects.filter(**{back_rel: comic_qs}).values("pk", "name").distinct()
         )
 
     @staticmethod
@@ -46,12 +70,14 @@ class BrowserChoicesViewBase(BrowserBaseView):
         """Get if null values exists for an m2m field."""
         return comic_qs.filter(**{f"{rel}__isnull": True}).exists()
 
-    @classmethod
-    def _get_rel_and_model(cls, field_name):
+    def _get_rel_and_model(self, field_name):
         """Return the relation and model for the field name."""
-        if field_name == cls.CREATOR_PERSON_UI_FIELD:
-            rel = cls.CREATORS_PERSON_REL
+        if field_name == self.CREATOR_PERSON_UI_FIELD:
+            rel = self._CREATORS_PERSON_REL
             model = CreatorPerson
+        elif field_name == self.STORY_ARC_UI_FIELD:
+            rel = self._STORY_ARC_REL
+            model = StoryArc
         else:
             remote_field = getattr(
                 Comic._meta.get_field(field_name), "remote_field", None
@@ -59,12 +85,21 @@ class BrowserChoicesViewBase(BrowserBaseView):
             rel = field_name
             model = remote_field.model if remote_field else None
 
+        rel = self.rel_prefix + rel
+
         return rel, model
 
     def get_object(self):
         """Get the comic subquery use for the choices."""
-        object_filter, _ = self.get_query_filters(True, True)
-        return Comic.objects.filter(object_filter)
+        object_filter, _ = self.get_query_filters(self.model, True)
+        return self.model.objects.filter(object_filter)
+
+    def _set_model(self):
+        """Set the model to query."""
+        group = self.kwargs["group"]
+        if group == self.ROOT_GROUP:
+            group = self.params.get("top_group", "p")
+        self.model = self.GROUP_MODEL_MAP[group]
 
 
 class BrowserChoicesAvailableView(BrowserChoicesViewBase):
@@ -72,23 +107,20 @@ class BrowserChoicesAvailableView(BrowserChoicesViewBase):
 
     serializer_class = BrowserFilterChoicesSerializer
 
-    CREATORS_PERSON_REL = "creators__person"
-
     @classmethod
-    def _get_field_choices_count(cls, field_name, comic_qs):
+    def _get_field_choices_count(cls, comic_qs, field_name):
         """Create a pk:name object for fields without tables."""
-        return cls.get_field_choices_query(field_name, comic_qs).count()
+        return cls.get_field_choices_query(comic_qs, field_name).count()
 
-    @classmethod
-    def _get_m2m_field_choices_count(cls, rel, comic_qs, model):
+    def _get_m2m_field_choices_count(self, model, comic_qs, rel):
         """Get choices with nulls where there are nulls."""
-        count = cls.get_m2m_field_query(rel, comic_qs, model).count()
+        count = self.get_m2m_field_query(model, comic_qs).count()
 
         # Detect if there are null choices.
         # Regretabbly with another query, but doing a forward query
         # on the comic above restricts all results to only the filtered
         # rows. :(
-        if cls.does_m2m_null_exist(comic_qs, rel):
+        if self.does_m2m_null_exist(comic_qs, rel):
             count += 1
 
         return count
@@ -97,16 +129,21 @@ class BrowserChoicesAvailableView(BrowserChoicesViewBase):
     def get(self, *args, **kwargs):
         """Return all choices with more than one choice."""
         self.parse_params()
+        self._set_model()
+        self.set_rel_prefix(self.model)
         comic_qs = self.get_object()
 
         data = {}
         for field_name in self.serializer_class().get_fields():  # type: ignore
+            if field_name == "story_arcs" and self.model == StoryArc:
+                # don't allow filtering on story arc in story arc view.
+                continue
             rel, m2m_model = self._get_rel_and_model(field_name)
 
             if m2m_model:
-                count = self._get_m2m_field_choices_count(rel, comic_qs, m2m_model)
+                count = self._get_m2m_field_choices_count(m2m_model, comic_qs, rel)
             else:
-                count = self._get_field_choices_count(rel, comic_qs)
+                count = self._get_field_choices_count(comic_qs, rel)
 
             filters = self.params.get("filters", {})
             data[field_name] = count > 1 or field_name in filters
@@ -120,10 +157,9 @@ class BrowserChoicesView(BrowserChoicesViewBase):
 
     serializer_class = BrowserChoicesSerializer
 
-    @classmethod
-    def _get_field_choices(cls, field_name, comic_qs):
+    def _get_field_choices(self, comic_qs, field_name):
         """Create a pk:name object for fields without tables."""
-        qs = cls.get_field_choices_query(field_name, comic_qs)
+        qs = self.get_field_choices_query(comic_qs, field_name)
 
         if field_name == "country":
             lookup = pycountry.countries
@@ -139,18 +175,17 @@ class BrowserChoicesView(BrowserChoicesViewBase):
 
         return choices
 
-    @classmethod
-    def _get_m2m_field_choices(cls, rel, comic_qs, model):
+    def _get_m2m_field_choices(self, model, comic_qs, rel):
         """Get choices with nulls where there are nulls."""
-        qs = cls.get_m2m_field_query(rel, comic_qs, model)
+        qs = self.get_m2m_field_query(model, comic_qs)
 
         # Detect if there are null choices.
         # Regretabbly with another query, but doing a forward query
         # on the comic above restrcts all results to only the filtered
         # rows. :(
-        if cls.does_m2m_null_exist(comic_qs, rel):
+        if self.does_m2m_null_exist(comic_qs, rel):
             choices = list(qs)
-            choices.append(cls.NULL_NAMED_ROW)
+            choices.append(self._NULL_NAMED_ROW)
         else:
             choices = qs
         return choices
@@ -159,6 +194,8 @@ class BrowserChoicesView(BrowserChoicesViewBase):
     def get(self, *args, **kwargs):
         """Return all choices with more than one choice."""
         self.parse_params()
+        self._set_model()
+        self.set_rel_prefix(self.model)
 
         field_name = snakecase(self.kwargs["field_name"])
 
@@ -166,9 +203,9 @@ class BrowserChoicesView(BrowserChoicesViewBase):
 
         comic_qs = self.get_object()
         if m2m_model:
-            choices = self._get_m2m_field_choices(rel, comic_qs, m2m_model)
+            choices = self._get_m2m_field_choices(m2m_model, comic_qs, rel)
         else:
-            choices = self._get_field_choices(rel, comic_qs)
+            choices = self._get_field_choices(comic_qs, rel)
 
         serializer = self.get_serializer(choices, many=True)
         return Response(serializer.data)

codex/views/browser/filters/bookmark.py

@@ -9,12 +9,10 @@ class BookmarkFilterMixin:
 
     _BOOKMARK_FILTERS = frozenset(set(CHOICES["bookmarkFilter"].keys()) - {"ALL"})
 
-    def get_bm_rel(self, is_model_comic):
+    def get_bm_rel(self, model):
         """Create bookmark relation."""
-        bm_rel = "bookmark"
-        if not is_model_comic:
-            bm_rel = "comic__" + bm_rel
-        return bm_rel
+        rel_prefix = self.get_rel_prefix(model)  # type: ignore
+        return rel_prefix + "bookmark"
 
     def _get_my_bookmark_filter(self, bm_rel):
         """Get a filter for my session or user defined bookmarks."""
@@ -27,12 +25,11 @@ class BookmarkFilterMixin:
             }
         return Q(**my_bookmarks_kwargs)
 
-    def get_bookmark_filter(self, is_model_comic, choice):
+    def get_bookmark_filter(self, model):
         """Build bookmark query."""
-        if choice is None:
-            choice = self.params["filters"].get("bookmark", "ALL")  # type: ignore
+        choice = self.params["filters"].get("bookmark", "ALL")  # type: ignore
         if choice in self._BOOKMARK_FILTERS:
-            bm_rel = self.get_bm_rel(is_model_comic)
+            bm_rel = self.get_bm_rel(model)
             my_bookmark_filter = self._get_my_bookmark_filter(bm_rel)
             if choice in ("UNREAD", "IN_PROGRESS"):
                 my_not_finished_filter = my_bookmark_filter & Q(

codex/views/browser/filters/field.py

@@ -7,18 +7,21 @@ from codex.views.session import BrowserSessionViewBase
 class ComicFieldFilter(BrowserSessionViewBase):
     """Comic field filters."""
 
-    def _filter_by_comic_field(self, field, is_model_comic):
+    def _filter_by_comic_field(self, field):
         """Filter by a comic any2many attribute."""
         filter_list = self.params["filters"].get(field)  # type: ignore
         filter_query = Q()
         if not filter_list:
             return filter_query
-        query_prefix = "" if is_model_comic else "comic__"
 
         if field == self.CREATOR_PERSON_UI_FIELD:
-            rel = f"{query_prefix}creators__person"
+            rel = "creators__person"
+        elif field == self.STORY_ARC_UI_FIELD:
+            rel = "storyarcnumber__story_arc"
         else:
-            rel = f"{query_prefix}{field}"
+            rel = field
+
+        rel = self.rel_prefix + rel  # type: ignore
 
         for index, val in enumerate(filter_list):
             # None values in a list don't work right so test for them separately
@@ -29,9 +32,9 @@ class ComicFieldFilter(BrowserSessionViewBase):
             filter_query |= Q(**{f"{rel}__in": filter_list})
         return filter_query
 
-    def get_comic_field_filter(self, is_model_comic):
+    def get_comic_field_filter(self):
         """Filter the comics based on the form filters."""
         comic_field_filter = Q()
         for attribute in self.FILTER_ATTRIBUTES:
-            comic_field_filter &= self._filter_by_comic_field(attribute, is_model_comic)
+            comic_field_filter &= self._filter_by_comic_field(attribute)
         return comic_field_filter

codex/views/browser/filters/group.py

@@ -7,35 +7,20 @@ from codex.views.mixins import GroupACLMixin
 class GroupFilterMixin(GroupACLMixin):
     """Group Filters."""
 
-    def _get_folders_filter(self):
-        """Get a filter for ALL parent folders not just immediate one."""
-        pk = self.kwargs.get("pk")  # type: ignore
-        return Q(folders__in=[pk]) if pk else Q()
-
-    def _get_browser_group_filter(self):
-        """Get the objects we'll be displaying."""
-        # Get the instances that are children of the group_instance
-        # And the filtered comics that are children of the group_instance
-        group_filter = Q()
-        pk = self.kwargs.get("pk")  # type: ignore
-        group = self.kwargs.get("group")  # type: ignore
-        if pk or group == self.FOLDER_GROUP:
-            if not pk:
-                pk = None
-            group_relation = self.GROUP_RELATION[group]
-            group_filter |= Q(**{group_relation: pk})
-
-        return group_filter
-
     def get_group_filter(self, choices):
         """Get filter for the displayed group."""
-        is_folder_view = self.kwargs.get("group") == self.FOLDER_GROUP  # type: ignore
-        if is_folder_view and choices:
-            # Choice view needs to get all descendant comic attributes
-            # So filter by all the folders
-            group_filter = self._get_folders_filter()
+        pk = self.kwargs.get("pk")  # type: ignore
+        group = self.kwargs.get("group")  # type: ignore
+        if pk:
+            group_relation = "comic__" if choices else ""
+            if choices and group == self.FOLDER_GROUP:
+                group_relation += "folders"
+            else:
+                group_relation += self.GROUP_RELATION[group]
+            group_filter = Q(**{group_relation: pk})
+        elif group == self.FOLDER_GROUP:
+            group_filter = Q(parent_folder=None)
         else:
-            # The browser filter is the same for all views
-            group_filter = self._get_browser_group_filter()
+            group_filter = Q()
 
         return group_filter

codex/views/browser/filters/search.py

@@ -23,19 +23,14 @@ class SearchFilterMixin:
             LOG.warning("While searching:")
             LOG.exception(exc)
 
-    def _get_search_query_filter(self, text, is_model_comic, search_scores):
+    def _get_search_query_filter(self, text, search_scores):
         """Get the search filter and scores."""
-        # Get search scores
+        rel = self.rel_prefix + "pk__in"  # type: ignore
         self._get_search_scores(text, search_scores)
-
-        # Create query
-        prefix = ""
-        if not is_model_comic:
-            prefix = "comic__"
-        query_dict = {f"{prefix}pk__in": search_scores.keys()}
+        query_dict = {rel: search_scores.keys()}
         return Q(**query_dict)
 
-    def get_search_filter(self, is_model_comic):
+    def get_search_filter(self):
         """Preparse search, search and return the filter and scores."""
         search_filter = Q()
         search_scores = {}
@@ -48,7 +43,7 @@ class SearchFilterMixin:
             if query_string:
                 # Query haystack
                 search_filter = self._get_search_query_filter(
-                    query_string, is_model_comic, search_scores
+                    query_string, search_scores
                 )
         except Exception as exc:
             LOG.warning(exc)