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

codex/views/browser/metadata.py

@@ -1,22 +1,20 @@
 """View for marking comics read and unread."""
 
 from types import MappingProxyType
+from typing import ClassVar
 
+from django.core.exceptions import FieldDoesNotExist
 from django.db.models import Count, IntegerField, Sum, Value
 from drf_spectacular.utils import extend_schema
 from rest_framework.exceptions import NotFound
 from rest_framework.response import Response
 
-from codex.librarian.importer.const import (
-    COMIC_M2M_FIELD_NAMES,
-)
+from codex.librarian.importer.const import COMIC_M2M_FIELD_NAMES
 from codex.logger.logging import get_logger
 from codex.models import AdminFlag, Comic
-from codex.models.functions import JsonGroupArray
-from codex.serializers.browser.metadata import PREFETCH_PREFIX, MetadataSerializer
-from codex.serializers.browser.settings import BrowserFilterChoicesInputSerilalizer
-from codex.views.browser.annotations import BrowserAnnotationsView
-from codex.views.const import METADATA_GROUP_RELATION
+from codex.serializers.browser.metadata import MetadataSerializer
+from codex.views.auth import IsAuthenticatedOrEnabledNonUsers
+from codex.views.browser.browser_annotations import BrowserAnnotationsView
 
 LOG = get_logger(__name__)
 _ADMIN_OR_FILE_VIEW_ENABLED_COMIC_VALUE_FIELDS = frozenset({"path"})
@@ -39,50 +37,25 @@ _COMIC_VALUE_FIELD_NAMES = frozenset(
 )
 _COMIC_VALUE_FIELDS_CONFLICTING_PREFIX = "conflict_"
 _COMIC_RELATED_VALUE_FIELDS = frozenset({"series__volume_count", "volume__issue_count"})
-_PATH_GROUPS = frozenset({"c", "f"})
+_PATH_GROUPS = ("c", "f")
 _CONTRIBUTOR_RELATIONS = ("role", "person")
 _SUM_FIELDS = frozenset({"page_count", "size"})
-_GROUP_RELS = MappingProxyType(
-    {
-        "i": ("publisher",),
-        "s": (
-            "publisher",
-            "imprint",
-        ),
-        "v": (
-            "publisher",
-            "imprint",
-            "series",
-        ),
-        "c": ("publisher", "imprint", "series", "volume"),
-    }
-)
+_GROUP_RELS = frozenset({"publisher", "imprint", "series", "volume"})
 
 
 class MetadataView(BrowserAnnotationsView):
     """Comic metadata."""
 
+    permission_classes: ClassVar[list] = [IsAuthenticatedOrEnabledNonUsers]  # type: ignore
     serializer_class = MetadataSerializer
-    input_serializer_class = BrowserFilterChoicesInputSerilalizer
     TARGET = "metadata"
     ADMIN_FLAG_VALUE_KEY_MAP = MappingProxyType(
         {
             AdminFlag.FlagChoices.FOLDER_VIEW.value: "folder_view",
+            AdminFlag.FlagChoices.DYNAMIC_GROUP_COVERS.value: "dynamic_group_covers",
         }
     )
 
-    def init_request(self):
-        """Initialize request."""
-        self.set_admin_flags()
-        self.parse_params()
-        self.set_model()
-        self.set_rel_prefix()
-
-    def set_valid_browse_nav_groups(self, valid_top_groups):  # noqa: ARG002
-        """Limited allowed nav groups for metadata."""
-        group = self.kwargs["group"]
-        self.valid_nav_groups = (group,)
-
     def _get_comic_value_fields(self):
         """Include the path field for staff."""
         fields = set(_COMIC_VALUE_FIELD_NAMES)
@@ -103,7 +76,6 @@ class MetadataView(BrowserAnnotationsView):
     ):
         """Annotate the intersection of value and fk fields."""
         (filtered_qs, qs) = querysets
-
         for field in fields:
             # Annotate variant counts
             # If 1 variant, annotate value, otherwise None
@@ -158,48 +130,6 @@ class MetadataView(BrowserAnnotationsView):
         )
         return qs
 
-    def _query_groups(self):
-        """Query the through models to show group lists."""
-        groups = {}
-        if not self.model:
-            return groups
-        group = self.kwargs["group"]
-        rel = METADATA_GROUP_RELATION.get(group)
-        if not rel:
-            return groups
-        rel = rel + "__in"
-        pks = self.kwargs["pks"]
-        group_filter = {rel: pks}
-
-        for field_name in _GROUP_RELS.get(group, ()):
-            field = self.model._meta.get_field(field_name)
-            model = field.related_model
-            if not model:
-                continue
-
-            qs = model.objects.filter(**group_filter)
-            qs = qs.only("name").distinct()
-            qs = qs.group_by("name")
-            qs = qs.annotate(ids=JsonGroupArray("id", distinct=True))
-            qs = qs.values("ids", "name")
-            groups[field_name] = qs
-        return groups
-
-    @staticmethod
-    def _get_optimized_m2m_query(key, qs):
-        if key == "contributors":
-            qs = qs.prefetch_related(*_CONTRIBUTOR_RELATIONS)
-            qs = qs.only(*_CONTRIBUTOR_RELATIONS)
-        elif key == "story_arc_numbers":
-            qs = qs.select_related("story_arc")
-            qs = qs.only("story_arc", "number")
-        elif key == "identifiers":
-            qs = qs.select_related("identifier_type")
-            qs = qs.only("identifier_type", "nss", "url")
-        else:
-            qs = qs.only("name")
-        return qs
-
     def _query_m2m_intersections(self, filtered_qs):
         """Query the through models to figure out m2m intersections."""
         # Speed ok, but still does a query per m2m model
@@ -207,17 +137,29 @@ class MetadataView(BrowserAnnotationsView):
         pk_field = self.rel_prefix + "pk"
         comic_pks = filtered_qs.values_list(pk_field, flat=True)
         comic_pks_count = comic_pks.count()
-        for field_name in COMIC_M2M_FIELD_NAMES:
+        for field_name in COMIC_M2M_FIELD_NAMES | _GROUP_RELS:
+            try:
+                if (
+                    field_name in _GROUP_RELS
+                    and self.model
+                    and not self.model._meta.get_field(field_name)
+                ):
+                    continue
+            except FieldDoesNotExist:
+                continue
+
             model = Comic._meta.get_field(field_name).related_model
             if not model:
                 reason = f"No model found for comic field: {field_name}"
                 raise ValueError(reason)
 
             intersection_qs = model.objects.filter(comic__pk__in=comic_pks)
+            if field_name in _GROUP_RELS:
+                group_by = "name" if field_name == "volume" else "sort_name"
+                intersection_qs = intersection_qs.group_by(group_by)
             intersection_qs = intersection_qs.alias(count=Count("comic")).filter(
                 count=comic_pks_count
             )
-            intersection_qs = self._get_optimized_m2m_query(field_name, intersection_qs)
 
             m2m_intersections[field_name] = intersection_qs
         return m2m_intersections
@@ -238,36 +180,42 @@ class MetadataView(BrowserAnnotationsView):
         """Values for highlighting the current group."""
         if self.model and not self.is_model_comic:
             # move the name of the group to the correct field
-            field = self.model.__name__.lower() + "_list"
-            group_list = self.model.objects.filter(pk__in=obj.ids).values("name")
-            setattr(obj, field, group_list)
+            group_field = self.model.__name__.lower()
+            group_obj = {"pk": obj.pk, "name": obj.name}
+            setattr(obj, group_field, group_obj)
             obj.name = None
 
+    @staticmethod
+    def _get_optimized_m2m_query(key, qs):
+        # XXX The prefetch gets removed by field.set() :(
+        if key == "contributors":
+            optimized_qs = qs.prefetch_related(*_CONTRIBUTOR_RELATIONS).only(
+                *_CONTRIBUTOR_RELATIONS
+            )
+        elif key == "story_arc_numbers":
+            optimized_qs = qs.prefetch_related("story_arc").only("story_arc", "number")
+        elif key == "identifiers":
+            optimized_qs = qs.prefetch_related("identifier_type").only(
+                "identifier_type", "nss", "url"
+            )
+        else:
+            optimized_qs = qs.only("name")
+        return optimized_qs
+
     @classmethod
     def _copy_m2m_intersections(cls, obj, m2m_intersections):
         """Copy the m2m intersections into the object."""
-        # XXX It might even be faster to copy everything to a dict and not use the obj.
-        for key, qs in m2m_intersections.items():
-            serializer_key = (
-                f"{PREFETCH_PREFIX}{key}"
-                if key in ("identifiers", "contributors", "story_arc_numbers")
-                else key
-            )
-            if hasattr(obj, serializer_key):
+        for key, value in m2m_intersections.items():
+            optimized_qs = cls._get_optimized_m2m_query(key, value)
+            if hasattr(obj, key) and key not in _GROUP_RELS:
                 # real db fields need to use their special set method.
-                field = getattr(obj, serializer_key)
-                field.set(
-                    qs,
-                    clear=True,
-                )
+                field = getattr(obj, key)
+                field.set(optimized_qs)
             else:
                 # fake db field is just a queryset attached.
-                setattr(obj, serializer_key, qs)
-
-    @staticmethod
-    def _copy_groups(obj, groups):
-        for field, group_qs in groups.items():
-            setattr(obj, field + "_list", group_qs)
+                if key in _GROUP_RELS:
+                    optimized_qs = optimized_qs[0] if len(optimized_qs) else None
+                setattr(obj, key, optimized_qs)
 
     @staticmethod
     def _copy_conflicting_simple_fields(obj):
@@ -277,11 +225,10 @@ class MetadataView(BrowserAnnotationsView):
             val = getattr(obj, conflict_field)
             setattr(obj, field, val)
 
-    def _copy_annotations_into_comic_fields(self, obj, groups, m2m_intersections):
+    def _copy_annotations_into_comic_fields(self, obj, m2m_intersections):
         """Copy a bunch of values that i couldn't fit cleanly in the main queryset."""
         self._path_security(obj)
         self._highlight_current_group(obj)
-        self._copy_groups(obj, groups)
         self._copy_m2m_intersections(obj, m2m_intersections)
         if not self.is_model_comic:
             self._copy_conflicting_simple_fields(obj)
@@ -301,28 +248,42 @@ class MetadataView(BrowserAnnotationsView):
         # values dicts don't copy relations to the serializer. The values
         # dict is necessary because of the folders view union in browser.py.
 
-        qs = self.get_filtered_queryset(self.model)
+        if self.model is None:
+            # TODO this looks redundant after set_browse_model
+            group = self.kwargs["group"]
+            raise NotFound(detail=f"Cannot get metadata for {group=}")
 
+        object_filter = self.get_query_filters_without_group(self.model)  # type: ignore
+        pks = self.kwargs["pks"]
+        qs = self.model.objects.filter(object_filter, pk__in=pks)
+        qs = self.filter_by_annotations(qs, self.model, binary=True)
         filtered_qs = qs
         qs = self.annotate_order_aggregates(qs, self.model)
         qs = self.annotate_card_aggregates(qs, self.model)
-        qs = self._annotate_values_and_fks(qs, filtered_qs)
+        qs = self.annotate_for_metadata(qs, self.model)
         group_by = self.get_group_by()
         qs = qs.group_by(group_by)
+        qs = self._annotate_values_and_fks(qs, filtered_qs)
+
+        qs_list = self.re_cover_multi_groups(qs)
 
         try:
-            obj = qs[0]
+            obj = qs_list[0]
             if not obj:
                 reason = "Empty obj"
                 raise ValueError(reason)  # noqa TRY301
         except (IndexError, ValueError) as exc:
             self._raise_not_found(exc)
 
-        groups = self._query_groups()
         m2m_intersections = self._query_m2m_intersections(filtered_qs)
-        return self._copy_annotations_into_comic_fields(obj, groups, m2m_intersections)  # type: ignore
+        return self._copy_annotations_into_comic_fields(obj, m2m_intersections)  # type: ignore
+
+    def set_valid_browse_nav_groups(self, _valid_top_groups):
+        """Limited allowed nav groups for metadata."""
+        group = self.kwargs["group"]
+        self.valid_nav_groups = (group,)
 
-    @extend_schema(parameters=[input_serializer_class])
+    @extend_schema(request=BrowserAnnotationsView.input_serializer_class)
     def get(self, *_args, **_kwargs):
         """Get metadata for a filtered browse group."""
         # Init

codex/views/browser/session.py

@@ -0,0 +1,12 @@
+"""Browser session view."""
+
+from codex.serializers.browser.settings import BrowserSettingsSerializer
+from codex.views.session import BrowserSessionViewBase, SessionViewBase
+
+
+class BrowserSessionView(BrowserSessionViewBase, SessionViewBase):
+    """Get Browser Settings."""
+
+    # Put Browser Settings is normally done through BrowserView.get()
+
+    serializer_class = BrowserSettingsSerializer  # type: ignore

codex/views/const.py

@@ -1,42 +1,7 @@
 """Common view constants."""
 
-from datetime import datetime, timezone
 from types import MappingProxyType
 
-from django.contrib.auth.models import Group, User
-from django.contrib.sessions.models import Session
-from django.db.models.expressions import Value
-from django.db.models.fields import DateTimeField, PositiveSmallIntegerField
-
-from codex.models import (
-    AgeRating,
-    BrowserGroupModel,
-    Character,
-    Comic,
-    Contributor,
-    ContributorPerson,
-    ContributorRole,
-    Country,
-    Folder,
-    Genre,
-    Identifier,
-    IdentifierType,
-    Imprint,
-    Language,
-    Library,
-    Location,
-    OriginalFormat,
-    Publisher,
-    ScanInfo,
-    Series,
-    SeriesGroup,
-    StoryArc,
-    StoryArcNumber,
-    Tag,
-    Tagger,
-    Team,
-    Volume,
-)
 from codex.settings.settings import CODEX_PATH
 
 FALSY = {None, "", "false", "0", False}
@@ -53,108 +18,3 @@ MISSING_COVER_NAME_MAP = MappingProxyType(
 )
 MISSING_COVER_FN = "missing-cover-165.webp"
 MISSING_COVER_PATH = STATIC_IMG_PATH / MISSING_COVER_FN
-
-
-ROOT_GROUP = "r"
-FOLDER_GROUP = "f"
-STORY_ARC_GROUP = "a"
-COMIC_GROUP = "c"
-GROUP_RELATION = MappingProxyType(
-    {
-        **GROUP_NAME_MAP,
-        COMIC_GROUP: "pk",
-        FOLDER_GROUP: "parent_folder",
-        STORY_ARC_GROUP: "story_arc_numbers__story_arc",
-    }
-)
-FILTER_ONLY_GROUP_RELATION = MappingProxyType(
-    {
-        **GROUP_NAME_MAP,
-        FOLDER_GROUP: "folders",
-        STORY_ARC_GROUP: "story_arc_numbers__story_arc",
-    }
-)
-METADATA_GROUP_RELATION = MappingProxyType(
-    {
-        **GROUP_NAME_MAP,
-        COMIC_GROUP: "pk",
-        # Possible to list all groups in a non group view, but could get crazy.
-        # FOLDER_GROUP: "comic__folder",
-        # STORY_ARC_GROUP: "comic__story_arc_number__story_arc"
-    }
-)
-CUSTOM_COVER_GROUP_RELATION = MappingProxyType(
-    {**GROUP_NAME_MAP, FOLDER_GROUP: "folder", STORY_ARC_GROUP: "storyarc"}
-)
-GROUP_ORDER = "rpisv"
-MODEL_REL_MAP = MappingProxyType(
-    {
-        Publisher: "publisher",
-        Imprint: "imprint",
-        Series: "series",
-        Volume: "volume",
-        Folder: "parent_folder",
-        StoryArc: "story_arc_numbers__story_arc",
-        Comic: "pk",
-    }
-)
-GROUP_MODEL_MAP: MappingProxyType[str, type[BrowserGroupModel] | None] = (
-    MappingProxyType(
-        {
-            ROOT_GROUP: None,
-            "p": Publisher,
-            "i": Imprint,
-            "s": Series,
-            "v": Volume,
-            COMIC_GROUP: Comic,
-            FOLDER_GROUP: Folder,
-            STORY_ARC_GROUP: StoryArc,
-        }
-    )
-)
-GROUP_MODELS = (
-    Publisher,
-    Imprint,
-    Series,
-    Volume,
-    Folder,
-    StoryArc,
-)
-STATS_GROUP_MODELS = (
-    *GROUP_MODELS,
-    Comic,
-)
-METADATA_MODELS = (
-    AgeRating,
-    Character,
-    Country,
-    Genre,
-    Identifier,
-    IdentifierType,
-    Language,
-    Location,
-    OriginalFormat,
-    SeriesGroup,
-    ScanInfo,
-    StoryArc,
-    StoryArcNumber,
-    Team,
-    Tag,
-    Tagger,
-    Contributor,
-    ContributorPerson,
-    ContributorRole,
-)
-CONFIG_MODELS = (
-    Library,
-    User,
-    Group,
-    Session,
-)
-MAX_OBJ_PER_PAGE = 100
-GROUP_MTIME_MODEL_MAP = MappingProxyType({"r": Publisher, "a": StoryArc, "f": Folder})
-EPOCH_START = datetime.fromtimestamp(0, tz=timezone.utc)
-ONE_INTEGERFIELD = Value(1, PositiveSmallIntegerField())
-NONE_INTEGERFIELD = Value(None, PositiveSmallIntegerField())
-NONE_DATETIMEFIELD = Value(None, DateTimeField())
-EPOCH_START_DATETIMEFIELD = Value(EPOCH_START)

codex/views/cover.py

@@ -0,0 +1,77 @@
+"""Comic cover thumbnail view."""
+
+from typing import ClassVar
+
+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 rest_framework.views import APIView
+
+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.views.auth import GroupACLMixin, IsAuthenticatedOrEnabledNonUsers
+from codex.views.const import 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(APIView, GroupACLMixin):
+    """ComicCover View."""
+
+    permission_classes: ClassVar[list] = [IsAuthenticatedOrEnabledNonUsers]  # type: ignore
+    renderer_classes = (WEBPRenderer,)
+    content_type = "image/webp"
+
+    def _get_missing_cover_path(self):
+        # Get the missing cover, which is a default svg if fetched for a group.
+        data = self.request.GET
+        group: str = data.get("group", "c")  # type: ignore
+        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
+
+    @extend_schema(responses={(200, content_type): OpenApiTypes.BINARY})
+    def get(self, *_args, **_kwargs):
+        """Get comic cover."""
+        thumb_image_data = None
+        content_type = "image/webp"
+
+        pk = self.kwargs.get("pk")
+        cover_path = CoverPathMixin.get_cover_path(pk)
+        if not cover_path.exists():
+            thumb_image_data = CoverCreateMixin.create_cover_from_path(
+                pk, cover_path, LOG, LIBRARIAN_QUEUE
+            )
+            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 HttpResponse(thumb_image_data, content_type=content_type)

codex/views/download.py

@@ -1,21 +1,24 @@
 """Download a comic archive."""
 
 from pathlib import Path
+from typing import ClassVar
 
 from django.http import FileResponse, Http404
 from drf_spectacular.types import OpenApiTypes
 from drf_spectacular.utils import extend_schema
+from rest_framework.views import APIView
 
 from codex.models import Comic
-from codex.views.auth import AuthFilterAPIView
+from codex.views.auth import GroupACLMixin, IsAuthenticatedOrEnabledNonUsers
 
 
-class DownloadView(AuthFilterAPIView):
+class DownloadView(APIView, GroupACLMixin):
     """Return the comic archive file as an attachment."""
 
+    permission_classes: ClassVar[list] = [IsAuthenticatedOrEnabledNonUsers]  # type: ignore
     content_type = "application/vnd.comicbook+zip"
 
-    _AS_ATTACHMENT = True
+    AS_ATTACHMENT = True
 
     @extend_schema(responses={(200, content_type): OpenApiTypes.BINARY})
     def get(self, *_args, **kwargs):
@@ -45,7 +48,7 @@ class DownloadView(AuthFilterAPIView):
         filename = comic.get_filename()
         return FileResponse(
             comic_file,
-            as_attachment=self._AS_ATTACHMENT,
+            as_attachment=self.AS_ATTACHMENT,
             content_type=content_type,
             filename=filename,
         )
@@ -54,4 +57,4 @@ class DownloadView(AuthFilterAPIView):
 class FileView(DownloadView):
     """View a comic in the browser."""
 
-    _AS_ATTACHMENT = False
+    AS_ATTACHMENT = False

codex/views/frontend.py

@@ -6,14 +6,12 @@ from rest_framework.renderers import TemplateHTMLRenderer
 from rest_framework.response import Response
 
 from codex.serializers.route import RouteSerializer
-from codex.views.session import SessionView
+from codex.views.session import BrowserSessionViewBase
 
 
-class IndexView(SessionView):
+class IndexView(BrowserSessionViewBase):
     """The main app."""
 
-    SESSION_KEY = SessionView.BROWSER_SESSION_KEY
-
     renderer_classes: ClassVar[list] = [TemplateHTMLRenderer]  # type: ignore
     template_name = "index.html"