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

codex/views/browser/choices.py

@@ -12,12 +12,7 @@ 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 CHOICES_SERIALIZER_CLASS_MAP
@@ -48,7 +43,6 @@ _FIELD_TO_REL_MODEL_MAP = MappingProxyType(
         ),
     }
 )
-_NULL_NAMED_ROW = MappingProxyType({"pk": -1, "name": "_none_"})
 _BACK_REL_MAP = MappingProxyType(
     {
         ContributorPerson: "contributor__",
@@ -56,24 +50,15 @@ _BACK_REL_MAP = MappingProxyType(
         IdentifierType: "identifier__",
     }
 )
-_CLASS_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
+_NULL_NAMED_ROW = MappingProxyType({"pk": -1, "name": "_none_"})
 
 
 class BrowserChoicesViewBase(BrowserAnnotationsFilterView):
     """Get choices for filter dialog."""
 
+    SERIALIZER_MANY = False
+    TARGET = "choices"
+
     @staticmethod
     def get_field_choices_query(comic_qs, field_name):
         """Get distinct values for the field."""
@@ -85,21 +70,13 @@ class BrowserChoicesViewBase(BrowserAnnotationsFilterView):
 
     def get_m2m_field_query(self, model, comic_qs: QuerySet):
         """Get distinct m2m value objects for the relation."""
-        if self.model is None:
-            LOG.error("No model to make filter choices!")
-            m2m_filter = {}
-        else:
-            model_rel: str = _CLASS_REL_MAP[self.model]  # type: ignore
-            back_rel = _BACK_REL_MAP.get(model, "")
-            back_rel += "comic__"
-            back_rel += model_rel
-            back_rel += "__in"
-            m2m_filter = {back_rel: comic_qs}
+        back_rel = _BACK_REL_MAP.get(model, "")
+        m2m_filter = {f"{back_rel}comic__in": comic_qs}
         return model.objects.filter(**m2m_filter).values("pk", "name").distinct()
 
     @staticmethod
     def does_m2m_null_exist(comic_qs, rel):
-        """Get if null values exists for an m2m field."""
+        """Get if comics exist in the filter without values exists for an m2m field."""
         return comic_qs.filter(**{f"{rel}__isnull": True}).exists()
 
     def get_rel_and_model(self, field_name):
@@ -114,22 +91,18 @@ 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."""
-        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)
+        return self.get_filtered_queryset(Comic)
 
     @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, many=_SERIALIZER_MANY)
+        serializer = self.get_serializer(obj, many=self.SERIALIZER_MANY)
         return Response(serializer.data)
 
 
@@ -162,6 +135,7 @@ 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:
@@ -174,9 +148,9 @@ class BrowserChoicesAvailableView(BrowserChoicesViewBase):
             else:
                 count = self._get_field_choices_count(qs, rel)
 
-            filters = self.params.get("filters", {})
             try:
-                flag = count > 1 or field_name in filters  # type: ignore
+                is_filter_set = bool(filters.get(field_name))
+                flag = is_filter_set or count > 1  # type: ignore
             except TypeError:
                 flag = False
             data[field_name] = flag
@@ -187,7 +161,9 @@ class BrowserChoicesView(BrowserChoicesViewBase):
     """Get choices for filter dialog."""
 
     # serializer_class = Dynamic class determined in get()
-    _SERIALIZER_MANY = True
+    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."""

codex/views/browser/cover.py

@@ -0,0 +1,177 @@
+"""Comic cover thumbnail view."""
+
+from django.http import HttpResponse
+from drf_spectacular.types import OpenApiTypes
+from drf_spectacular.utils import extend_schema
+from rest_framework.renderers import BaseRenderer
+
+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.paths import CustomCover
+from codex.serializers.choices import DEFAULTS
+from codex.views.browser.annotations import BrowserAnnotationsView
+from codex.views.const import (
+    GROUP_RELATION,
+    MISSING_COVER_FN,
+    MISSING_COVER_NAME_MAP,
+    STATIC_IMG_PATH,
+)
+
+LOG = get_logger(__name__)
+
+
+class WEBPRenderer(BaseRenderer):
+    """Render WEBP images."""
+
+    media_type = "image/webp"
+    format = "webp"
+    charset = None
+    render_style = "binary"
+
+    def render(self, data, *_args, **_kwargs):
+        """Return raw data."""
+        return data
+
+
+class CoverView(BrowserAnnotationsView):
+    """ComicCover View."""
+
+    renderer_classes = (WEBPRenderer,)
+    content_type = "image/webp"
+    TARGET = "cover"
+
+    def get_model_group(self):
+        """Return the url group."""
+        return self.kwargs["group"]
+
+    def init_request(self):
+        """Initialize request."""
+        self.parse_params()
+        self.set_model()
+
+    def _get_comic_cover(self):
+        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_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)
+        comic_qs = comic_qs.only("pk")
+        group_by = self.get_group_by(Comic)
+        comic_qs.group_by(group_by)
+        comic = comic_qs.first()
+        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()
+        else:
+            cover_pk, custom = self._get_first_cover()
+        return cover_pk, custom
+
+    def _get_missing_cover_path(self):
+        """Get the missing cover, which is a default svg if fetched for a group."""
+        group: str = self.kwargs["group"]
+        cover_name = MISSING_COVER_NAME_MAP.get(group)
+        if cover_name:
+            cover_fn = cover_name + ".svg"
+            content_type = "image/svg+xml"
+        else:
+            cover_fn = MISSING_COVER_FN
+            content_type = "image/webp"
+        cover_path = STATIC_IMG_PATH / cover_fn
+        return cover_path, content_type
+
+    def _get_cover_data(self, pk, custom):
+        thumb_image_data = None
+        content_type = "image/webp"
+
+        cover_path = CoverPathMixin.get_cover_path(pk, custom)
+        if not cover_path.exists():
+            thumb_image_data = CoverCreateMixin.create_cover_from_path(
+                pk, cover_path, LOG, LIBRARIAN_QUEUE, custom
+            )
+            if not thumb_image_data:
+                cover_path, content_type = self._get_missing_cover_path()
+        elif cover_path.stat().st_size == 0:
+            cover_path, content_type = self._get_missing_cover_path()
+
+        if not thumb_image_data:
+            # if not thumb_image_data:
+            with cover_path.open("rb") as f:
+                thumb_image_data = f.read()
+        return thumb_image_data, content_type
+
+    @extend_schema(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)

codex/views/browser/filters/annotations.py

@@ -1,34 +1,79 @@
 """Annotations used by a filter."""
 
-from django.db.models.aggregates import Count
-from django.db.models.expressions import Value
-from django.db.models.fields import PositiveSmallIntegerField
+from django.db.models.aggregates import Count, Max
+from django.db.models.functions import Coalesce, Greatest
 
 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,
+    ONE_INTEGERFIELD,
+)
 
 
-class BrowserAnnotationsFilterView(BrowserValidateView):
+class BrowserAnnotationsFilterView(BrowserValidateView, BookmarkFilterMixin):
     """Annotations that also filter."""
 
-    ONE_INTEGERFIELD = Value(1, PositiveSmallIntegerField())
+    def __init__(self, *args, **kwargs) -> None:
+        """Initialize."""
+        super().__init__(*args, **kwargs)
+        self.init_bookmark_data()
 
-    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)
+    def _get_query_filters(self, model, group, pks, bookmark_filter):
+        """Return all the filters except the group filter."""
+        object_filter = self.get_group_acl_filter(model)
+        object_filter &= self.get_group_filter(model, group, pks)
+        object_filter &= self.get_comic_field_filter(model)
+        if bookmark_filter:
+            # not needed because 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}
         if self.TARGET == "opds2":
             if model != Comic:
-                qs = qs.alias(child_count=child_count_sum)
+                qs = qs.alias(**ann)
         else:
-            qs = qs.annotate(child_count=child_count_sum)
+            qs = qs.annotate(**ann)
         if model != Comic:
-            qs = qs.filter(child_count__gt=0)
+            qs = qs.filter(**{f"{ann_name}__gt": 0})
         return qs
 
-    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)
+    def get_filtered_queryset(self, model, group=None, pks=None, bookmark_filter=True):
+        """Get a filtered queryset for the model."""
+        object_filter = self._get_query_filters(model, group, pks, bookmark_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):
+        """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
+        )
+        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_DATETIMEFILED
+        qs = qs.annotate(max_bookmark_updated_at=mbua)
+
+        mtime = qs.aggregate(
+            max=Greatest(
+                Coalesce("max_bookmark_updated_at", EPOCH_START_DATETIMEFILED),
+                "max_updated_at",
+            )
+        )["max"]
+        if mtime == NotImplemented:
+            mtime = None
+        return mtime

codex/views/browser/filters/bookmark.py

@@ -1,17 +1,26 @@
 """Bookmark filter view methods."""
 
+from typing import TYPE_CHECKING
+
 from django.db.models import Q
 
+if TYPE_CHECKING:
+    from codex.models import BrowserGroupModel
+
 
 class BookmarkFilterMixin:
     """BookmarkFilter view methods."""
 
-    def get_bm_rel(self, model):
+    def init_bookmark_data(self):
+        """Initialize the bm_annotation_data."""
+        self._bm_annotation_data: dict[BrowserGroupModel, tuple[str, Q]] = {}
+
+    def _get_bm_rel(self, model):
         """Create bookmark relation."""
         rel_prefix = self.get_rel_prefix(model)  # type: ignore
         return rel_prefix + "bookmark"
 
-    def get_my_bookmark_filter(self, bm_rel):
+    def _get_my_bookmark_filter(self, bm_rel):
         """Get a filter for my session or user defined bookmarks."""
         if self.request.user.is_authenticated:  # type: ignore
             my_bookmarks_kwargs = {f"{bm_rel}__user": self.request.user}  # type: ignore
@@ -22,12 +31,19 @@ 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 = self.params["filters"].get("bookmark", "")  # type: ignore
+        choice: str = self.params.get("filters", {}).get("bookmark", "")  # type: ignore
         if choice:
-            bm_rel = self.get_bm_rel(model)
-            my_bookmark_filter = self.get_my_bookmark_filter(bm_rel)
+            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}

codex/views/browser/filters/field.py

@@ -5,7 +5,6 @@ from types import MappingProxyType
 from django.db.models import Q
 
 from codex.models.comic import Comic
-from codex.views.browser.filters.bookmark import BookmarkFilterMixin
 from codex.views.browser.filters.group import GroupFilterView
 
 _FILTER_REL_MAP = MappingProxyType(
@@ -17,7 +16,7 @@ _FILTER_REL_MAP = MappingProxyType(
 )
 
 
-class ComicFieldFilterView(GroupFilterView, BookmarkFilterMixin):
+class ComicFieldFilterView(GroupFilterView):
     """Comic field filters."""
 
     def _filter_by_comic_field(self, field, rel_prefix):

codex/views/browser/filters/group.py

@@ -2,7 +2,8 @@
 
 from django.db.models import Q
 
-from codex.views.const import FOLDER_GROUP, GROUP_RELATION
+from codex.models import Comic
+from codex.views.const import FOLDER_GROUP, GROUP_MODEL_MAP, GROUP_RELATION
 from codex.views.session import SessionView
 
 
@@ -11,18 +12,25 @@ class GroupFilterView(SessionView):
 
     SESSION_KEY = SessionView.BROWSER_SESSION_KEY
 
-    def get_group_filter(self, choices):
+    def get_group_filter(self, model, group=None, pks=None):
         """Get filter for the displayed 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 == FOLDER_GROUP:
-                group_relation += "folders"
+        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:
-                group_relation += GROUP_RELATION[group]
-            group_relation += "__in"
-            group_filter_dict = {group_relation: pks}  # type: ignore
+                rel = GROUP_RELATION[group]
+
+            rel += "__in"
+            group_filter_dict = {rel: pks}  # type: ignore
         elif group == FOLDER_GROUP:
             group_filter_dict = {"parent_folder": None}
         else:

codex/views/browser/filters/search.py

@@ -30,6 +30,8 @@ class SearchScorePks:
 class SearchFilterView(ComicFieldFilterView):
     """Search Filters Methods."""
 
+    TARGET = ""
+
     def _is_search_results_limited(self) -> bool:
         """Get search result limit from params."""
         # user = self.request.user  # type: ignore
@@ -115,7 +117,7 @@ class SearchFilterView(ComicFieldFilterView):
 
         return tuple(scores_pairs), tuple(prev_pks), tuple(next_pks), tuple(scored_pks)
 
-    def _get_search_scores(self, binary=False):
+    def _get_search_scores(self, model, qs):
         """Perform the search and return the scores as a dict."""
         text = self.params.get("q", "")  # type: ignore
         if not text:
@@ -128,13 +130,21 @@ class SearchFilterView(ComicFieldFilterView):
         try:
             sqs = CodexSearchQuerySet()
             sqs = sqs.auto_query(text)  # .filter(score__gt=0.0)
-            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)
+            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)
+                binary = (
+                    self.TARGET in frozenset({"cover", "choices"})
+                    or self.params.get("order_by", "") != "search_score"
                 )
+                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:
@@ -171,17 +181,16 @@ class SearchFilterView(ComicFieldFilterView):
         rel = prefix + "pk__in"
         return {rel: scored_pks}
 
-    def apply_search_filter(self, qs, model, binary=False):
+    def apply_search_filter(self, qs, model):
         """Preparse search, search and return the filter and scores."""
         try:
             score_pairs, prev_pks, next_pks, scored_pks = self._get_search_scores(
-                binary
+                model, qs
             )
             qs = self.annotate_search_score(qs, model, score_pairs, prev_pks, next_pks)
             if score_pairs or scored_pks:
                 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")