codex 1.6.0__py3-none-any.whl → 1.6.0a0__py3-none-any.whl

codex/views/browser/choices.py

@@ -1,7 +1,9 @@
 """View for marking comics read and unread."""
 
 from types import MappingProxyType
+from typing import ClassVar
 
+import pycountry
 from caseconverter import snakecase
 from django.db.models import QuerySet
 from drf_spectacular.utils import extend_schema
@@ -11,17 +13,21 @@ from codex.logger.logging import get_logger
 from codex.models import (
     Comic,
     ContributorPerson,
+    Folder,
+    Imprint,
+    Publisher,
+    Series,
     StoryArc,
+    Volume,
 )
 from codex.models.named import IdentifierType
-from codex.serializers.browser.choices import (
-    BrowserChoicesFilterSerializer,
-)
+from codex.serializers.browser.choices import CHOICES_SERIALIZER_CLASS_MAP
 from codex.serializers.browser.filters import (
     BrowserFilterChoicesSerializer,
+    CharListField,
 )
-from codex.serializers.browser.settings import BrowserFilterChoicesInputSerilalizer
-from codex.serializers.choices import DUMMY_NULL_NAME, VUETIFY_NULL_CODE
+from codex.serializers.models.pycountry import PyCountrySerializer
+from codex.views.auth import IsAuthenticatedOrEnabledNonUsers
 from codex.views.browser.filters.annotations import (
     BrowserAnnotationsFilterView,
 )
@@ -44,27 +50,37 @@ _FIELD_TO_REL_MODEL_MAP = MappingProxyType(
         ),
     }
 )
-_BACK_REL_MAP = MappingProxyType(
-    {
-        ContributorPerson: "contributor__",
-        StoryArc: "storyarcnumber__",
-        IdentifierType: "identifier__",
-    }
-)
-_NULL_NAMED_ROW = MappingProxyType({"pk": VUETIFY_NULL_CODE, "name": DUMMY_NULL_NAME})
 
 
 class BrowserChoicesViewBase(BrowserAnnotationsFilterView):
     """Get choices for filter dialog."""
 
-    input_serializer_class = BrowserFilterChoicesInputSerilalizer
-    TARGET = "choices"
-
-    def init_request(self):
-        """Initialieze request."""
-        self.parse_params()
-        self.set_model()
-        self.set_rel_prefix()
+    permission_classes: ClassVar[list] = [IsAuthenticatedOrEnabledNonUsers]  # type: ignore
+
+    _CONTRIBUTORS_PERSON_REL = "contributors__person"
+    _STORY_ARC_REL = "story_arc_numbers__story_arc"
+    _IDENTIFIERS_REL = "identifiers__identifier_type"
+    _NULL_NAMED_ROW = MappingProxyType({"pk": -1, "name": "_none_"})
+    _BACK_REL_MAP = MappingProxyType(
+        {
+            ContributorPerson: "contributor__",
+            StoryArc: "storyarcnumber__",
+            IdentifierType: "identifier__",
+        }
+    )
+    _REL_MAP = MappingProxyType(
+        {
+            Publisher: "publisher",
+            Imprint: "imprint",
+            Series: "series",
+            Volume: "volume",
+            Comic: "pk",
+            Folder: "parent_folder",
+            StoryArc: "story_arc_numbers__story_arc",
+            IdentifierType: "identifiers__identifier_type",
+        }
+    )
+    _SERIALIZER_MANY = False
 
     @staticmethod
     def get_field_choices_query(comic_qs, field_name):
@@ -77,13 +93,21 @@ class BrowserChoicesViewBase(BrowserAnnotationsFilterView):
 
     def get_m2m_field_query(self, model, comic_qs: QuerySet):
         """Get distinct m2m value objects for the relation."""
-        back_rel = _BACK_REL_MAP.get(model, "")
-        m2m_filter = {f"{back_rel}comic__in": comic_qs}
+        if self.model is None:
+            LOG.error("No model to make filter choices!")
+            m2m_filter = {}
+        else:
+            model_rel: str = self._REL_MAP[self.model]  # type: ignore
+            back_rel = self._BACK_REL_MAP.get(model, "")
+            back_rel += "comic__"
+            back_rel += model_rel
+            back_rel += "__in"
+            m2m_filter = {back_rel: comic_qs}
         return model.objects.filter(**m2m_filter).values("pk", "name").distinct()
 
     @staticmethod
     def does_m2m_null_exist(comic_qs, rel):
-        """Get if comics exist in the filter without values exists for an m2m field."""
+        """Get if null values exists for an m2m field."""
         return comic_qs.filter(**{f"{rel}__isnull": True}).exists()
 
     def get_rel_and_model(self, field_name):
@@ -98,18 +122,22 @@ class BrowserChoicesViewBase(BrowserAnnotationsFilterView):
             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."""
-        return self.get_filtered_queryset(Comic)
+        object_filter = self.get_query_filters(self.model, choices=True)
+        qs = self.model.objects.filter(object_filter)  # type: ignore
+        return self.filter_by_annotations(qs, self.model, binary=True)
 
-    @extend_schema(parameters=[input_serializer_class])
+    @extend_schema(request=BrowserAnnotationsFilterView.input_serializer_class)
     def get(self, *_args, **_kwargs):
         """Return choices."""
         self.init_request()
         obj = self.get_object()
-        serializer = self.get_serializer(obj)
+        serializer = self.get_serializer(obj, many=self._SERIALIZER_MANY)
         return Response(serializer.data)
 
 
@@ -142,7 +170,6 @@ class BrowserChoicesAvailableView(BrowserChoicesViewBase):
     def get_object(self):
         """Get choice counts."""
         qs = super().get_object()
-        filters = self.params.get("filters", {})
         data = {}
         for field_name in self.serializer_class().get_fields():  # type: ignore
             if field_name == "story_arcs" and self.model == StoryArc:
@@ -155,9 +182,9 @@ class BrowserChoicesAvailableView(BrowserChoicesViewBase):
             else:
                 count = self._get_field_choices_count(qs, rel)
 
+            filters = self.params.get("filters", {})
             try:
-                is_filter_set = bool(filters.get(field_name))
-                flag = is_filter_set or count > 1  # type: ignore
+                flag = count > 1 or field_name in filters  # type: ignore
             except TypeError:
                 flag = False
             data[field_name] = flag
@@ -167,7 +194,26 @@ class BrowserChoicesAvailableView(BrowserChoicesViewBase):
 class BrowserChoicesView(BrowserChoicesViewBase):
     """Get choices for filter dialog."""
 
-    serializer_class = BrowserChoicesFilterSerializer
+    # serializer_class = Dynamic class determined in get()
+    _SERIALIZER_MANY = True
+
+    def _get_field_choices(self, comic_qs, field_name):
+        """Create a pk:name object for fields without tables."""
+        qs = self.get_field_choices_query(comic_qs, field_name)
+
+        if field_name == "country":
+            lookup = pycountry.countries
+        elif field_name == "language":
+            lookup = pycountry.languages
+        else:
+            lookup = None
+
+        choices = []
+        for val in qs:
+            name = PyCountrySerializer.lookup_name(lookup, val) if lookup else val
+            choices.append({"pk": val, "name": name})
+
+        return choices
 
     def _get_m2m_field_choices(self, model, comic_qs, rel):
         """Get choices with nulls where there are nulls."""
@@ -179,7 +225,7 @@ class BrowserChoicesView(BrowserChoicesViewBase):
         # rows. :(
         if self.does_m2m_null_exist(comic_qs, rel):
             choices = list(qs)
-            choices.append(_NULL_NAMED_ROW)
+            choices.append(self._NULL_NAMED_ROW)
         else:
             choices = qs
         return choices
@@ -188,6 +234,11 @@ class BrowserChoicesView(BrowserChoicesViewBase):
         field_name = self.kwargs.get("field_name", "")
         return snakecase(field_name)
 
+    def get_serializer_class(self):  # type: ignore
+        """Dynamic serializer class."""
+        field_name = self._get_field_name()
+        return CHOICES_SERIALIZER_CLASS_MAP.get(field_name, CharListField)
+
     def get_object(self):
         """Return choices with more than one choice."""
         qs = super().get_object()
@@ -197,9 +248,5 @@ class BrowserChoicesView(BrowserChoicesViewBase):
         if m2m_model:
             choices = self._get_m2m_field_choices(m2m_model, qs, rel)
         else:
-            choices = self.get_field_choices_query(qs, field_name)
-
-        return {
-            "field_name": field_name,
-            "choices": choices,
-        }
+            choices = self._get_field_choices(qs, rel)
+        return choices

codex/views/browser/const.py

@@ -0,0 +1,3 @@
+"""Browser constants."""
+
+MAX_OBJ_PER_PAGE = 100

codex/views/browser/filters/annotations.py

@@ -1,102 +1,34 @@
 """Annotations used by a filter."""
 
-from django.db.models.aggregates import Count, Max
-from django.db.models.functions import Coalesce, Greatest
+from django.db.models.aggregates import Count
+from django.db.models.expressions import Value
+from django.db.models.fields import PositiveSmallIntegerField
 
 from codex.models.comic import Comic
-from codex.views.browser.filters.bookmark import BookmarkFilterMixin
-from codex.views.browser.validate import BrowserValidateView
-from codex.views.const import (
-    EPOCH_START_DATETIMEFIELD,
-    ONE_INTEGERFIELD,
-)
+from codex.views.browser.base import BrowserBaseView
 
 
-class BrowserAnnotationsFilterView(BrowserValidateView, BookmarkFilterMixin):
+class BrowserAnnotationsFilterView(BrowserBaseView):
     """Annotations that also filter."""
 
-    def __init__(self, *args, **kwargs) -> None:
-        """Initialize."""
-        super().__init__(*args, **kwargs)
-        self.init_bookmark_data()
+    ONE_INTEGERFIELD = Value(1, PositiveSmallIntegerField())
 
-    def _get_query_filters(  # noqa: PLR0913
-        self, model, group, pks, bookmark_filter, page_mtime=False, group_filter=True
-    ):
-        """Return all the filters except the group filter."""
-        # TODO all these ifs and flags are awful
-        object_filter = self.get_group_acl_filter(model)
-        if group_filter:
-            object_filter &= self.get_group_filter(group, pks, page_mtime=page_mtime)
-        object_filter &= self.get_comic_field_filter(model)
-        if bookmark_filter:
-            # not needed when used by outerrefl OuterRef is applied next
-            object_filter &= self.get_bookmark_filter(model)
-        return object_filter
-
-    def _filter_by_child_count(self, qs, model):
-        """Filter group by child count."""
-        rel = self.rel_prefix + "pk"
-        ann_name = "child_count"
-        count_func = ONE_INTEGERFIELD if model == Comic else Count(rel, distinct=True)
-        ann = {ann_name: count_func}
+    def _annotate_child_count(self, qs, model):
+        """Annotate Child Count."""
+        if model == Comic:
+            child_count_sum = self.ONE_INTEGERFIELD
+        else:
+            child_count_sum = Count(self.rel_prefix + "pk", distinct=True)
         if self.TARGET == "opds2":
             if model != Comic:
-                qs = qs.alias(**ann)
+                qs = qs.alias(child_count=child_count_sum)
         else:
-            qs = qs.annotate(**ann)
+            qs = qs.annotate(child_count=child_count_sum)
         if model != Comic:
-            qs = qs.filter(**{f"{ann_name}__gt": 0})
+            qs = qs.filter(child_count__gt=0)
         return qs
 
-    def get_filtered_queryset(  # noqa: PLR0913
-        self,
-        model,
-        group=None,
-        pks=None,
-        bookmark_filter=True,
-        page_mtime=False,
-        group_filter=True,
-    ):
-        """Get a filtered queryset for the model."""
-        object_filter = self._get_query_filters(
-            model,
-            group,
-            pks,
-            bookmark_filter,
-            page_mtime=page_mtime,
-            group_filter=group_filter,
-        )
-        qs = model.objects.filter(object_filter)
-        qs = self.apply_search_filter(qs, model)
-        return self._filter_by_child_count(qs, model)
-
-    def get_group_mtime(self, model, group=None, pks=None, page_mtime=False):
-        """Get a filtered mtime for browser pages and mtime checker."""
-        qs = self.get_filtered_queryset(
-            model,
-            group=group,
-            pks=pks,
-            bookmark_filter=self.is_bookmark_filtered,
-            page_mtime=page_mtime,
-        )
-        qs = qs.annotate(max_updated_at=Max("updated_at"))
-
-        if self.is_bookmark_filtered:
-            bm_rel, bm_filter = self.get_bookmark_rel_and_filter(model)
-            qs = qs.filter(bm_filter)
-            ua_rel = bm_rel + "__updated_at"
-            mbua = Max(ua_rel)
-        else:
-            mbua = EPOCH_START_DATETIMEFIELD
-        qs = qs.annotate(max_bookmark_updated_at=mbua)
-
-        mtime = qs.aggregate(
-            max=Greatest(
-                Coalesce("max_bookmark_updated_at", EPOCH_START_DATETIMEFIELD),
-                "max_updated_at",
-            )
-        )["max"]
-        if mtime == NotImplemented:
-            mtime = None
-        return mtime
+    def filter_by_annotations(self, qs, model, binary=False):
+        """Filter queryset by annotations."""
+        qs = self._annotate_child_count(qs, model)
+        return self.apply_search_filter(qs, model, binary=binary)

codex/views/browser/filters/bookmark.py

@@ -1,21 +1,16 @@
 """Bookmark filter view methods."""
 
-from typing import TYPE_CHECKING
-
 from django.db.models import Q
 
-if TYPE_CHECKING:
-    from codex.models import BrowserGroupModel
+from codex.serializers.choices import CHOICES
 
 
 class BookmarkFilterMixin:
     """BookmarkFilter view methods."""
 
-    def init_bookmark_data(self):
-        """Initialize the bm_annotation_data."""
-        self._bm_annotation_data: dict[BrowserGroupModel, tuple[str, Q]] = {}
+    _BOOKMARK_FILTERS = frozenset(set(CHOICES["bookmarkFilter"].keys()) - {"ALL"})
 
-    def _get_bm_rel(self, model):
+    def get_bm_rel(self, model):
         """Create bookmark relation."""
         rel_prefix = self.get_rel_prefix(model)  # type: ignore
         return rel_prefix + "bookmark"
@@ -31,24 +26,13 @@ class BookmarkFilterMixin:
             }
         return Q(**my_bookmarks_kwargs)
 
-    def get_bookmark_rel_and_filter(self, model):
-        """Get the bookmark rel and filter once."""
-        if model not in self._bm_annotation_data:
-            bm_rel = self._get_bm_rel(model)
-            bm_filter = self._get_my_bookmark_filter(bm_rel)
-            self._bm_annotation_data[model] = (bm_rel, bm_filter)
-        return self._bm_annotation_data[model]
-
     def get_bookmark_filter(self, model):
         """Build bookmark query."""
-        choice: str = self.params.get("filters", {}).get("bookmark", "")  # type: ignore
-        if choice:
-            bm_rel, my_bookmark_filter = self.get_bookmark_rel_and_filter(model)
-            if choice == "READ":
-                bookmark_filter = my_bookmark_filter & Q(
-                    **{f"{bm_rel}__finished": True}
-                )
-            else:
+        choice = self.params["filters"].get("bookmark", "ALL")  # type: ignore
+        if choice in self._BOOKMARK_FILTERS:
+            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(
                     **{f"{bm_rel}__finished__in": (False, None)}
                 )
@@ -58,6 +42,10 @@ class BookmarkFilterMixin:
                     bookmark_filter = my_not_finished_filter & Q(
                         **{f"{bm_rel}__page__gt": 0}
                     )
+            else:  # READ
+                bookmark_filter = my_bookmark_filter & Q(
+                    **{f"{bm_rel}__finished": True}
+                )
         else:
             bookmark_filter = Q()
         return bookmark_filter

codex/views/browser/filters/field.py

@@ -4,19 +4,18 @@ from types import MappingProxyType
 
 from django.db.models import Q
 
-from codex.models.comic import Comic
-from codex.views.browser.filters.group import GroupFilterView
+from codex.views.session import BrowserSessionViewBase
 
 _FILTER_REL_MAP = MappingProxyType(
     {
-        GroupFilterView.CONTRIBUTOR_PERSON_UI_FIELD: "contributors__person",
-        GroupFilterView.STORY_ARC_UI_FIELD: "story_arc_numbers__story_arc",
-        GroupFilterView.IDENTIFIER_TYPE_UI_FIELD: "identifiers__identifier_type",
+        BrowserSessionViewBase.CONTRIBUTOR_PERSON_UI_FIELD: "contributors__person",
+        BrowserSessionViewBase.STORY_ARC_UI_FIELD: "story_arc_numbers__story_arc",
+        BrowserSessionViewBase.IDENTIFIER_TYPE_UI_FIELD: "identifiers__identifier_type",
     }
 )
 
 
-class ComicFieldFilterView(GroupFilterView):
+class ComicFieldFilter(BrowserSessionViewBase):
     """Comic field filters."""
 
     def _filter_by_comic_field(self, field, rel_prefix):
@@ -37,10 +36,9 @@ class ComicFieldFilterView(GroupFilterView):
             filter_query |= Q(**{f"{rel}__in": filter_list})
         return filter_query
 
-    def get_comic_field_filter(self, model):
+    def get_comic_field_filter(self, rel_prefix):
         """Filter the comics based on the form filters."""
         comic_field_filter = Q()
-        rel_prefix = "" if model == Comic else self.rel_prefix  # type: ignore
         for attribute in self.FILTER_ATTRIBUTES:
             comic_field_filter &= self._filter_by_comic_field(attribute, rel_prefix)
         return comic_field_filter

codex/views/browser/filters/group.py

@@ -2,46 +2,25 @@
 
 from django.db.models import Q
 
-from codex.views.const import (
-    FILTER_ONLY_GROUP_RELATION,
-    FOLDER_GROUP,
-    GROUP_RELATION,
-)
-from codex.views.session import SessionView
+from codex.views.auth import GroupACLMixin
 
 
-class GroupFilterView(SessionView):
+class GroupFilterMixin(GroupACLMixin):
     """Group Filters."""
 
-    SESSION_KEY = SessionView.BROWSER_SESSION_KEY
-
-    def _get_rel_for_pks(self, group, page_mtime=False):
-        """Get the relation from the model to the pks."""
-        # XXX these TARGET refs might be better as subclass get rel methods.
-        target: str = self.TARGET  # type: ignore
-        if target in ("cover", "choices"):
-            rel = FILTER_ONLY_GROUP_RELATION[group]
-        elif target in ("metadata", "mtime") or page_mtime:
-            # metadata, mtime, browser.page_mtime
-            rel = "pk"
-        else:
-            # browser.group, opds
-            rel = GROUP_RELATION[group]
-
-        rel += "__in"
-        return rel
-
-    def get_group_filter(self, group=None, pks=None, page_mtime=False):
+    def get_group_filter(self, choices):
         """Get filter for the displayed group."""
-        if group is None:
-            group = self.kwargs["group"]
-        if pks is None:
-            pks = self.kwargs["pks"]
-
-        if pks and 0 not in pks:
-            rel = self._get_rel_for_pks(group, page_mtime)
-            group_filter_dict = {rel: pks}
-        elif group == FOLDER_GROUP:
+        group = self.kwargs["group"]  # type: ignore
+        pks = self.kwargs["pks"]  # type: ignore
+        if pks:  # type: ignore
+            group_relation = "comic__" if choices else ""
+            if choices and group == self.FOLDER_GROUP:
+                group_relation += "folders"
+            else:
+                group_relation += self.GROUP_RELATION[group]
+            group_relation += "__in"
+            group_filter_dict = {group_relation: pks}  # type: ignore
+        elif group == self.FOLDER_GROUP:
             group_filter_dict = {"parent_folder": None}
         else:
             group_filter_dict = {}

codex/views/browser/filters/search.py

@@ -9,13 +9,12 @@ from codex.logger.logging import get_logger
 from codex.models import Comic
 from codex.search.query import CodexSearchQuerySet
 from codex.settings.settings import DEBUG
-from codex.views.browser.filters.field import ComicFieldFilterView
-from codex.views.const import MAX_OBJ_PER_PAGE
+from codex.views.browser.const import MAX_OBJ_PER_PAGE
 
 LOG = get_logger(__name__)
-_SEARCH_SCORE_MAX = 100.0
-_SEARCH_SCORE_MIN = 0.001
-_SEARCH_SCORE_EMPTY = 0.0
+SEARCH_SCORE_MAX = 100.0
+SEARCH_SCORE_MIN = 0.001
+SEARCH_SCORE_EMPTY = 0.0
 
 
 @dataclass
@@ -27,11 +26,9 @@ class SearchScorePks:
     next_pks: tuple[int, ...] = ()
 
 
-class SearchFilterView(ComicFieldFilterView):
+class SearchFilterMixin:
     """Search Filters Methods."""
 
-    TARGET = ""
-
     def _is_search_results_limited(self) -> bool:
         """Get search result limit from params."""
         # user = self.request.user  # type: ignore
@@ -117,7 +114,7 @@ class SearchFilterView(ComicFieldFilterView):
 
         return tuple(scores_pairs), tuple(prev_pks), tuple(next_pks), tuple(scored_pks)
 
-    def _get_search_scores(self, model, qs):
+    def _get_search_scores(self, binary=False):
         """Perform the search and return the scores as a dict."""
         text = self.params.get("q", "")  # type: ignore
         if not text:
@@ -130,20 +127,13 @@ class SearchFilterView(ComicFieldFilterView):
         try:
             sqs = CodexSearchQuerySet()
             sqs = sqs.auto_query(text)  # .filter(score__gt=0.0)
-            prefix = "" if model == Comic else self.rel_prefix  # type: ignore
-            comic_ids = qs.values_list(prefix + "pk", flat=True)
-            if comic_ids:
-                # Prefilter comic ids. If nothing is allowed, don't search.
-                sqs = sqs.filter_comic_ids(comic_ids)
-                if (
-                    self.TARGET in frozenset({"cover", "choices"})
-                    or self.params.get("order_by", "") != "search_score"  # type: ignore
-                ):
-                    scored_pks = self._get_binary_search_scores(sqs)
-                else:
-                    score_pairs, prev_pks, next_pks, scored_pks = (
-                        self._get_browser_search_scores(sqs)
-                    )
+            binary = binary or self.params.get("order_by") != "search_score"  # type: ignore
+            if binary:
+                scored_pks = self._get_binary_search_scores(sqs)
+            else:
+                score_pairs, prev_pks, next_pks, scored_pks = (
+                    self._get_browser_search_scores(sqs)
+                )
         except MemoryError:
             LOG.warning("Search engine needs more memory, results truncated.")
         except Exception:
@@ -164,12 +154,10 @@ class SearchFilterView(ComicFieldFilterView):
                 when = {prefix + "pk": pk, "then": score}
                 whens.append(When(**when))
             if prev_pks:
-                whens.append(When(pk__in=prev_pks, then=_SEARCH_SCORE_MAX))
+                whens.append(When(pk__in=prev_pks, then=SEARCH_SCORE_MAX))
             if next_pks:
-                whens.append(When(pk__in=next_pks, then=_SEARCH_SCORE_MIN))
-            search_score = self.order_agg_func(  # type: ignore
-                Case(*whens, default=_SEARCH_SCORE_EMPTY)
-            )
+                whens.append(When(pk__in=next_pks, then=SEARCH_SCORE_MIN))
+            search_score = self.order_agg_func(Case(*whens, default=SEARCH_SCORE_EMPTY))  # type: ignore
         else:
             search_score = Value(0.0)
         return qs.annotate(search_score=search_score)
@@ -180,16 +168,17 @@ class SearchFilterView(ComicFieldFilterView):
         rel = prefix + "pk__in"
         return {rel: scored_pks}
 
-    def apply_search_filter(self, qs, model):
+    def apply_search_filter(self, qs, model, binary=False):
         """Preparse search, search and return the filter and scores."""
         try:
             score_pairs, prev_pks, next_pks, scored_pks = self._get_search_scores(
-                model, qs
+                binary
             )
             qs = self.annotate_search_score(qs, model, score_pairs, prev_pks, next_pks)
-            if score_pairs or scored_pks:
+            if score_pairs:
                 search_filter = self._get_search_query_filter(model, scored_pks)
                 qs = qs.filter(**search_filter)
+                self.cover_search_score_pairs = score_pairs
         except Exception:
             LOG.exception("Creating the search filter")