codex 1.6.0a9__py3-none-any.whl → 1.6.0a11__py3-none-any.whl

codex/views/browser/browser.py

@@ -16,9 +16,6 @@ from codex.models import (
     Folder,
     Imprint,
     Library,
-    Publisher,
-    Series,
-    StoryArc,
     Volume,
 )
 from codex.serializers.browser.page import BrowserPageSerializer
@@ -26,6 +23,7 @@ from codex.views.browser.title import BrowserTitleView
 from codex.views.const import (
     COMIC_GROUP,
     FOLDER_GROUP,
+    NONE_DATETIMEFIELD,
     STORY_ARC_GROUP,
 )
 
@@ -34,6 +32,15 @@ if TYPE_CHECKING:
 
 
 LOG = get_logger(__name__)
+_GROUP_INSTANCE_SELECT_RELATED: MappingProxyType[
+    type[BrowserGroupModel], tuple[str | None, ...]
+] = MappingProxyType(
+    {
+        Comic: ("series", "volume"),
+        Volume: ("series",),
+        Imprint: ("publisher",),
+    }
+)
 
 
 class BrowserView(BrowserTitleView):
@@ -48,19 +55,6 @@ class BrowserView(BrowserTitleView):
         }
     )
     TARGET = "browser"
-    _GROUP_INSTANCE_SELECT_RELATED: MappingProxyType[
-        type[BrowserGroupModel], tuple[str | None, ...]
-    ] = MappingProxyType(
-        {
-            Comic: ("series", "volume"),
-            Volume: ("series",),
-            Series: (None,),
-            Imprint: ("publisher",),
-            Publisher: (None,),
-            Folder: ("parent_folder",),
-            StoryArc: (None,),
-        }
-    )
 
     def __init__(self, *args, **kwargs):
         """Set params for the type checker."""
@@ -75,7 +69,7 @@ class BrowserView(BrowserTitleView):
         if pks and self.group_class:
             try:
                 select_related: tuple[str | None, ...] = (
-                    self._GROUP_INSTANCE_SELECT_RELATED[self.group_class]
+                    _GROUP_INSTANCE_SELECT_RELATED.get(self.group_class, (None,))
                 )
                 self.group_query = self.group_class.objects.select_related(
                     *select_related
@@ -156,13 +150,23 @@ class BrowserView(BrowserTitleView):
             count = 0
         return qs, count
 
-    def _get_page_mtime(self):
-        if not self.is_bookmark_filtered and self.group_instance:
-            # Nice optimization if we can get get it.
-            return self.group_instance.updated_at
+    def _requery_max_bookmark_updated_at(self, group_qs):
+        """Get max updated at without bookmark filter and aware of multi-groups."""
+        if not self.is_bookmark_filtered:
+            return group_qs
 
-        group_model = self.group_class if self.group_class else self.model
-        return self.get_group_mtime(group_model)
+        bm_rel, bm_filter = self.get_bookmark_rel_and_filter(self.model)
+        bm_updated_at_rel = f"{bm_rel}__updated_at"
+        max_bmua = Max(bm_updated_at_rel, default=NONE_DATETIMEFIELD, filter=bm_filter)
+
+        group_list = []
+        for group in group_qs:
+            qs = self.get_filtered_queryset(
+                self.model, bookmark_filter=False, group_filter=False
+            )
+            group.max_bookmark_updated_at = qs.aggregate(max=max_bmua)["max"]
+            group_list.append(group)
+        return group_list
 
     @staticmethod
     def _get_zero_pad(book_qs):
@@ -175,6 +179,14 @@ class BrowserView(BrowserTitleView):
             zero_pad += floor(log10(issue_number_max))
         return zero_pad
 
+    def _get_page_mtime(self):
+        if not self.is_bookmark_filtered and self.group_instance:
+            # Nice optimization if we can get get it.
+            return self.group_instance.updated_at
+
+        group_model = self.group_class if self.group_class else self.model
+        return self.get_group_mtime(group_model, page_mtime=True)
+
     def _get_group_and_books(self):
         """Create the main queries with filters, annotation and pagination."""
         group_qs, group_count = self._get_group_queryset()
@@ -185,6 +197,7 @@ class BrowserView(BrowserTitleView):
         )
         if page_group_count:
             group_qs = self.annotate_card_aggregates(group_qs, self.model)
+            group_qs = self._requery_max_bookmark_updated_at(group_qs)
         if page_book_count:
             zero_pad = self._get_zero_pad(book_qs)
             book_qs = self.annotate_card_aggregates(book_qs, Comic)
@@ -205,7 +218,7 @@ class BrowserView(BrowserTitleView):
         )
 
         # get additional context
-        parent_breadcrumbs = self.get_parent_breadcrumbs()
+        breadcrumbs = self.get_breadcrumbs()
         title = self.get_browser_page_title()
         # needs to happen after pagination
         # runs obj list query twice :/
@@ -214,7 +227,7 @@ class BrowserView(BrowserTitleView):
         # construct final data structure
         return MappingProxyType(
             {
-                "breadcrumbs": parent_breadcrumbs,
+                "breadcrumbs": breadcrumbs,
                 "title": title,
                 "model_group": self.model_group,
                 "groups": group_qs,
@@ -228,11 +241,10 @@ class BrowserView(BrowserTitleView):
             }
         )
 
-    @extend_schema(request=BrowserTitleView.input_serializer_class)
+    @extend_schema(parameters=[BrowserTitleView.input_serializer_class])
     def get(self, *_args, **_kwargs):
         """Get browser settings."""
         self.init_request()
         data = self.get_object()
         serializer = self.get_serializer(data)
-        self.save_params_to_session(self.params)
         return Response(serializer.data)

codex/views/browser/choices.py

@@ -2,7 +2,6 @@
 
 from types import MappingProxyType
 
-import pycountry
 from caseconverter import snakecase
 from django.db.models import QuerySet
 from drf_spectacular.utils import extend_schema
@@ -15,12 +14,14 @@ from codex.models import (
     StoryArc,
 )
 from codex.models.named import IdentifierType
-from codex.serializers.browser.choices import CHOICES_SERIALIZER_CLASS_MAP
+from codex.serializers.browser.choices import (
+    BrowserChoicesFilterSerializer,
+)
 from codex.serializers.browser.filters import (
     BrowserFilterChoicesSerializer,
-    CharListField,
 )
-from codex.serializers.models.pycountry import PyCountrySerializer
+from codex.serializers.browser.settings import BrowserFilterChoicesInputSerilalizer
+from codex.serializers.choices import DUMMY_NULL_NAME, VUETIFY_NULL_CODE
 from codex.views.browser.filters.annotations import (
     BrowserAnnotationsFilterView,
 )
@@ -50,15 +51,21 @@ _BACK_REL_MAP = MappingProxyType(
         IdentifierType: "identifier__",
     }
 )
-_NULL_NAMED_ROW = MappingProxyType({"pk": -1, "name": "_none_"})
+_NULL_NAMED_ROW = MappingProxyType({"pk": VUETIFY_NULL_CODE, "name": DUMMY_NULL_NAME})
 
 
 class BrowserChoicesViewBase(BrowserAnnotationsFilterView):
     """Get choices for filter dialog."""
 
-    SERIALIZER_MANY = False
+    input_serializer_class = BrowserFilterChoicesInputSerilalizer
     TARGET = "choices"
 
+    def init_request(self):
+        """Initialieze request."""
+        self.parse_params()
+        self.set_model()
+        self.set_rel_prefix()
+
     @staticmethod
     def get_field_choices_query(comic_qs, field_name):
         """Get distinct values for the field."""
@@ -97,12 +104,12 @@ class BrowserChoicesViewBase(BrowserAnnotationsFilterView):
         """Get the comic subquery use for the choices."""
         return self.get_filtered_queryset(Comic)
 
-    @extend_schema(request=BrowserAnnotationsFilterView.input_serializer_class)
+    @extend_schema(parameters=[input_serializer_class])
     def get(self, *_args, **_kwargs):
         """Return choices."""
         self.init_request()
         obj = self.get_object()
-        serializer = self.get_serializer(obj, many=self.SERIALIZER_MANY)
+        serializer = self.get_serializer(obj)
         return Response(serializer.data)
 
 
@@ -160,28 +167,7 @@ class BrowserChoicesAvailableView(BrowserChoicesViewBase):
 class BrowserChoicesView(BrowserChoicesViewBase):
     """Get choices for filter dialog."""
 
-    # serializer_class = Dynamic class determined in get()
-    SERIALIZER_MANY = True
-    # HACK get_serializer(data, many=True) requires this to be set for the debug API view
-    queryset = Comic.objects.none()
-
-    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
+    serializer_class = BrowserChoicesFilterSerializer
 
     def _get_m2m_field_choices(self, model, comic_qs, rel):
         """Get choices with nulls where there are nulls."""
@@ -202,11 +188,6 @@ 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()
@@ -216,5 +197,9 @@ class BrowserChoicesView(BrowserChoicesViewBase):
         if m2m_model:
             choices = self._get_m2m_field_choices(m2m_model, qs, rel)
         else:
-            choices = self._get_field_choices(qs, rel)
-        return choices
+            choices = self.get_field_choices_query(qs, field_name)
+
+        return {
+            "field_name": field_name,
+            "choices": choices,
+        }

codex/views/browser/cover.py

@@ -1,5 +1,6 @@
 """Comic cover thumbnail view."""
 
+from django.db.models.query import Q
 from django.http import HttpResponse
 from drf_spectacular.types import OpenApiTypes
 from drf_spectacular.utils import extend_schema
@@ -9,11 +10,12 @@ from codex.librarian.covers.create import CoverCreateMixin
 from codex.librarian.covers.path import CoverPathMixin
 from codex.librarian.mp_queue import LIBRARIAN_QUEUE
 from codex.logger.logging import get_logger
-from codex.models import Comic, Folder, Volume
+from codex.models import Comic, Volume
 from codex.models.paths import CustomCover
-from codex.serializers.choices import DEFAULTS
+from codex.serializers.browser.settings import BrowserCoverInputSerializer
 from codex.views.browser.annotations import BrowserAnnotationsView
 from codex.views.const import (
+    CUSTOM_COVER_GROUP_RELATION,
     GROUP_RELATION,
     MISSING_COVER_FN,
     MISSING_COVER_NAME_MAP,
@@ -39,9 +41,34 @@ class WEBPRenderer(BaseRenderer):
 class CoverView(BrowserAnnotationsView):
     """ComicCover View."""
 
+    input_serializer_class = BrowserCoverInputSerializer
     renderer_classes = (WEBPRenderer,)
     content_type = "image/webp"
     TARGET = "cover"
+    REPARSE_JSON_FIELDS = frozenset(
+        BrowserAnnotationsView.REPARSE_JSON_FIELDS | {"parent"}
+    )
+
+    def get_group_filter(self, group=None, pks=None, page_mtime=False):
+        """Get group filter for First Cover View."""
+        if self.params.get("dynamic_covers"):
+            return super().get_group_filter(group=group, pks=pks, page_mtime=page_mtime)
+
+        # First cover group filter relies on sort names to look outside the browser supplied pks
+        # For multi_groups not in the browser query.
+        pks = self.kwargs["pks"]
+        name_rel = "name" if self.model == Volume else "sort_name"
+        qs = self.model.objects.filter(pk__in=pks)  # type: ignore
+        sort_names = qs.values_list(name_rel, flat=True).distinct()
+        model_rel = GROUP_RELATION[self.model_group]
+        group_filter = {f"{model_rel}__{name_rel}__in": sort_names}
+
+        parent = self.params["parent"]
+        parent_pks = parent.get("pks", ())
+        if parent_pks:
+            parent_rel = GROUP_RELATION[parent["group"]]
+            group_filter[f"{parent_rel}__pk__in"] = parent_pks
+        return Q(**group_filter)
 
     def get_model_group(self):
         """Return the url group."""
@@ -56,39 +83,21 @@ class CoverView(BrowserAnnotationsView):
         pks = self.kwargs["pks"]
         return pks[0], False
 
-    def _use_dynamic_cover(self):
-        if not self.params.get("dynamic_covers"):
-            return False
-        filters = self.params.get("filters", {})
-        for key, value in filters.items():
-            if key == "bookmark" and value != DEFAULTS["bookmarkFilter"]:
-                return True
-            if value:
-                return True
-
-        order_by = self.params.get("order_by")
-        default_order_by = "filename" if self.model == Folder else "sort_name"
-        if order_by != default_order_by:
-            return True
-
-        if self.params.get("order_reverse"):
-            return True
-
-        return False
+    def _get_custom_cover(self):
+        """Get Custom Cover."""
+        if self.model == Volume or not self.params.get("custom_covers"):
+            return None
+        group = self.kwargs["group"]
+        group_rel = CUSTOM_COVER_GROUP_RELATION[group]
+        pks = self.kwargs["pks"]
+        comic_filter = {f"{group_rel}__in": pks}
+        qs = CustomCover.objects.filter(**comic_filter)
+        qs = qs.only("pk")
+        return qs.first()
 
     def _get_dynamic_cover(self):
         """Get dynamic cover."""
         self.set_order_key()
-        pks = self.kwargs["pks"]
-
-        if self.model != Volume and self.params.get("custom_covers"):
-            group = self.kwargs["group"]
-            group_rel = "folder" if self.model == Folder else GROUP_RELATION[group]  # type: ignore
-            comic_filter = {f"{group_rel}__in": pks}
-            custom_cover = CustomCover.objects.filter(**comic_filter).only("pk").first()
-            if custom_cover:
-                return custom_cover.pk, True
-
         comic_qs = self.get_filtered_queryset(Comic)
         comic_qs = self.annotate_order_aggregates(comic_qs, Comic)
         comic_qs = self.add_order_by(comic_qs, Comic)
@@ -99,40 +108,15 @@ class CoverView(BrowserAnnotationsView):
         cover_pk = comic.pk if comic else 0
         return cover_pk, False
 
-    def _get_first_cover(self):
-        """Get first cover."""
-        pks = self.kwargs["pks"]
-        order_by = (
-            "path"
-            if self.model == Folder
-            else "name"
-            if self.model == Volume
-            else "sort_name"
-        )
-        group_qs = self.model.objects.filter(pk__in=pks)  # type: ignore
-        group_qs = group_qs.order_by(order_by)
-        select_related = ["first_comic"]
-        custom_covers = self.params.get("custom_covers")
-        if custom_covers and self.model != Volume:
-            select_related.append("custom_cover")
-        group_qs = group_qs.select_related(*select_related)
-        group_qs = group_qs.group_by("id")  # type: ignore
-        group_obj = group_qs.first()
-        if custom_covers and self.model != Volume and group_obj.custom_cover:
-            return group_obj.custom_cover.pk, True
-        cover_pk = (
-            group_obj.first_comic.pk if group_obj and group_obj.first_comic else 0
-        )
-        return cover_pk, False
-
     def _get_cover_pk(self) -> tuple[int, bool]:
         """Get Cover Pk queryset for comic queryset."""
         if self.model == Comic:
             cover_pk, custom = self._get_comic_cover()
-        elif self._use_dynamic_cover():
-            cover_pk, custom = self._get_dynamic_cover()
+        elif custom_cover := self._get_custom_cover():
+            cover_pk = custom_cover.pk
+            custom = True
         else:
-            cover_pk, custom = self._get_first_cover()
+            cover_pk, custom = self._get_dynamic_cover()
         return cover_pk, custom
 
     def _get_missing_cover_path(self):
@@ -168,10 +152,16 @@ class CoverView(BrowserAnnotationsView):
                 thumb_image_data = f.read()
         return thumb_image_data, content_type
 
-    @extend_schema(responses={(200, content_type): OpenApiTypes.BINARY})
+    @extend_schema(
+        parameters=[BrowserAnnotationsView.input_serializer_class],
+        responses={(200, content_type): OpenApiTypes.BINARY},
+    )
     def get(self, *args, **kwargs):  # type: ignore
         """Get comic cover."""
-        self.init_request()
-        pk, custom = self._get_cover_pk()
-        thumb_image_data, content_type = self._get_cover_data(pk, custom)
-        return HttpResponse(thumb_image_data, content_type=content_type)
+        try:
+            self.init_request()
+            pk, custom = self._get_cover_pk()
+            thumb_image_data, content_type = self._get_cover_data(pk, custom)
+            return HttpResponse(thumb_image_data, content_type=content_type)
+        except Exception:
+            LOG.exception("get")

codex/views/browser/filters/annotations.py

@@ -7,7 +7,7 @@ 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_DATETIMEFILED,
+    EPOCH_START_DATETIMEFIELD,
     ONE_INTEGERFIELD,
 )
 
@@ -20,13 +20,17 @@ class BrowserAnnotationsFilterView(BrowserValidateView, BookmarkFilterMixin):
         super().__init__(*args, **kwargs)
         self.init_bookmark_data()
 
-    def _get_query_filters(self, model, group, pks, bookmark_filter):
+    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)
-        object_filter &= self.get_group_filter(model, group, pks)
+        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 because OuterRef is applied next
+            # not needed when used by outerrefl OuterRef is applied next
             object_filter &= self.get_bookmark_filter(model)
         return object_filter
 
@@ -45,17 +49,36 @@ class BrowserAnnotationsFilterView(BrowserValidateView, BookmarkFilterMixin):
             qs = qs.filter(**{f"{ann_name}__gt": 0})
         return qs
 
-    def get_filtered_queryset(self, model, group=None, pks=None, bookmark_filter=True):
+    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)
+        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):
+    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
+            model,
+            group=group,
+            pks=pks,
+            bookmark_filter=self.is_bookmark_filtered,
+            page_mtime=page_mtime,
         )
         qs = qs.annotate(max_updated_at=Max("updated_at"))
 
@@ -65,12 +88,12 @@ class BrowserAnnotationsFilterView(BrowserValidateView, BookmarkFilterMixin):
             ua_rel = bm_rel + "__updated_at"
             mbua = Max(ua_rel)
         else:
-            mbua = EPOCH_START_DATETIMEFILED
+            mbua = EPOCH_START_DATETIMEFIELD
         qs = qs.annotate(max_bookmark_updated_at=mbua)
 
         mtime = qs.aggregate(
             max=Greatest(
-                Coalesce("max_bookmark_updated_at", EPOCH_START_DATETIMEFILED),
+                Coalesce("max_bookmark_updated_at", EPOCH_START_DATETIMEFIELD),
                 "max_updated_at",
             )
         )["max"]

codex/views/browser/filters/group.py

@@ -2,8 +2,11 @@
 
 from django.db.models import Q
 
-from codex.models import Comic
-from codex.views.const import FOLDER_GROUP, GROUP_MODEL_MAP, GROUP_RELATION
+from codex.views.const import (
+    FILTER_ONLY_GROUP_RELATION,
+    FOLDER_GROUP,
+    GROUP_RELATION,
+)
 from codex.views.session import SessionView
 
 
@@ -12,25 +15,31 @@ class GroupFilterView(SessionView):
 
     SESSION_KEY = SessionView.BROWSER_SESSION_KEY
 
-    def get_group_filter(self, model, group=None, pks=None):
+    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 ("metadata", "mtime") or page_mtime:
+            # metadata, mtime, browser.page_mtime
+            rel = "pk"
+        elif target in ("choices", "cover"):
+            rel = FILTER_ONLY_GROUP_RELATION[group]
+        else:
+            rel = GROUP_RELATION[group]
+
+        rel += "__in"
+        return rel
+
+    def get_group_filter(self, group=None, pks=None, page_mtime=False):
         """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:  # type: ignore
-            if model == GROUP_MODEL_MAP.get(group):
-                # metadata only
-                rel = "pk"
-            elif model == Comic and group == FOLDER_GROUP:
-                # choices & covers
-                rel = "folders"
-            else:
-                rel = GROUP_RELATION[group]
-
-            rel += "__in"
-            group_filter_dict = {rel: pks}  # type: ignore
+        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_filter_dict = {"parent_folder": None}
         else:

codex/views/browser/filters/search.py

@@ -135,11 +135,10 @@ class SearchFilterView(ComicFieldFilterView):
             if comic_ids:
                 # Prefilter comic ids. If nothing is allowed, don't search.
                 sqs = sqs.filter_comic_ids(comic_ids)
-                binary = (
+                if (
                     self.TARGET in frozenset({"cover", "choices"})
-                    or self.params.get("order_by", "") != "search_score"
-                )
-                if binary:
+                    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 = (