codex 1.6.0a8__py3-none-any.whl → 1.6.0a10__py3-none-any.whl

codex/views/browser/metadata.py

@@ -13,8 +13,10 @@ from codex.librarian.importer.const import (
 )
 from codex.logger.logging import get_logger
 from codex.models import AdminFlag, Comic
-from codex.serializers.browser.metadata import MetadataSerializer
+from codex.models.functions import JsonGroupArray
+from codex.serializers.browser.metadata import PREFETCH_PREFIX, MetadataSerializer
 from codex.views.browser.annotations import BrowserAnnotationsView
+from codex.views.const import METADATA_GROUP_RELATION
 
 LOG = get_logger(__name__)
 _ADMIN_OR_FILE_VIEW_ENABLED_COMIC_VALUE_FIELDS = frozenset({"path"})
@@ -54,6 +56,13 @@ class MetadataView(BrowserAnnotationsView):
         }
     )
 
+    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"]
@@ -79,6 +88,7 @@ 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
@@ -133,6 +143,52 @@ 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:
+            try:
+                field = self.model._meta.get_field(field_name)
+            except FieldDoesNotExist:
+                continue
+            model = field.related_model
+            if not model:
+                continue
+
+            qs = model.objects.filter(**group_filter)
+            qs = qs.only("name").distinct()
+            group_by = self.get_group_by(model)
+            qs = qs.group_by(group_by)
+            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
@@ -140,31 +196,17 @@ 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 | _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
-
+        for field_name in COMIC_M2M_FIELD_NAMES:
             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)
-            if field_name == "identifiers":
-                intersection_qs = intersection_qs.select_related("identifier_type")
             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
@@ -185,42 +227,37 @@ 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
-            group_field = self.model.__name__.lower()
+            field = self.model.__name__.lower() + "_list"
             group_obj = {"pk": obj.pk, "name": obj.name}
-            setattr(obj, group_field, group_obj)
+            group_list = [group_obj]
+            setattr(obj, field, group_list)
             obj.name = None
 
-    @staticmethod
-    def _get_optimized_m2m_query(key, qs):
-        # XXX The prefetch gets removed by field.set() :(
-        if key == "contributors":
-            qs = qs.prefetch_related(*_CONTRIBUTOR_RELATIONS).only(
-                *_CONTRIBUTOR_RELATIONS
-            )
-        elif key == "story_arc_numbers":
-            qs = qs.prefetch_related("story_arc")
-            qs = qs.only("story_arc", "number")
-        elif key == "identifiers":
-            qs = qs.prefetch_related("identifier_type")
-            qs = qs.only("identifier_type", "nss", "url")
-        else:
-            qs = qs.only("name")
-        return qs
-
     @classmethod
     def _copy_m2m_intersections(cls, obj, m2m_intersections):
         """Copy the m2m intersections into the object."""
-        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:
+        # 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):
                 # real db fields need to use their special set method.
-                field = getattr(obj, key)
-                field.set(optimized_qs)
+                field = getattr(obj, serializer_key)
+                field.set(
+                    qs,
+                    clear=True,
+                )
             else:
                 # fake db field is just a queryset attached.
-                if key in _GROUP_RELS:
-                    optimized_qs = optimized_qs[0] if len(optimized_qs) else None
-                setattr(obj, key, optimized_qs)
+                setattr(obj, serializer_key, qs)
+
+    @staticmethod
+    def _copy_groups(obj, groups):
+        for field, group_qs in groups.items():
+            setattr(obj, field + "_list", group_qs)
 
     @staticmethod
     def _copy_conflicting_simple_fields(obj):
@@ -230,10 +267,11 @@ class MetadataView(BrowserAnnotationsView):
             val = getattr(obj, conflict_field)
             setattr(obj, field, val)
 
-    def _copy_annotations_into_comic_fields(self, obj, m2m_intersections):
+    def _copy_annotations_into_comic_fields(self, obj, groups, 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)
@@ -270,10 +308,11 @@ class MetadataView(BrowserAnnotationsView):
         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, m2m_intersections)  # type: ignore
+        return self._copy_annotations_into_comic_fields(obj, groups, m2m_intersections)  # type: ignore
 
-    @extend_schema(request=BrowserAnnotationsView.input_serializer_class)
+    @extend_schema(parameters=[BrowserAnnotationsView.input_serializer_class])
     def get(self, *_args, **_kwargs):
         """Get metadata for a filtered browse group."""
         # Init

codex/views/browser/mtime.py

@@ -0,0 +1,61 @@
+"""Get the mtimes for the submitted groups."""
+
+from drf_spectacular.utils import extend_schema
+from rest_framework.response import Response
+
+from codex.logger.logging import get_logger
+from codex.models.groups import Publisher
+from codex.serializers.browser.mtime import GroupsMtimeSerializer, MtimeSerializer
+from codex.util import max_none
+from codex.views.browser.filters.annotations import BrowserAnnotationsFilterView
+from codex.views.const import GROUP_MODEL_MAP
+
+LOG = get_logger(__name__)
+
+
+class MtimeView(BrowserAnnotationsFilterView):
+    """Get the mtimes for the submitted groups."""
+
+    input_serializer_class = GroupsMtimeSerializer
+    serializer_class = MtimeSerializer
+
+    REPARSE_JSON_FIELDS = frozenset({"groups", "filters"})
+    TARGET = "mtime"
+
+    def __init__(self, *args, **kwargs) -> None:
+        """Initialize."""
+        super().__init__(*args, **kwargs)
+        self.init_bookmark_data()
+
+    def _get_group_mtime(self, item):
+        """Get one group's mtimes."""
+        group = item["group"]
+        pks = item["pks"]
+
+        model = GROUP_MODEL_MAP[group]
+        if not model:
+            model = Publisher
+
+        return self.get_group_mtime(model, group, pks)
+
+    def get_max_groups_mtime(self):
+        """Get max mtime for all groups."""
+        max_mtime = None
+
+        for item in self.params["groups"]:  # type: ignore
+            mtime = self._get_group_mtime(item)
+            max_mtime = max_none(max_mtime, mtime)
+        return max_mtime
+
+    @extend_schema(parameters=[GroupsMtimeSerializer])
+    def get(self, *args, **kwargs):
+        """Get the mtimes for the submitted groups."""
+        # Parse Request
+        self.parse_params()
+
+        max_mtime = self.get_max_groups_mtime()
+
+        # Serialize Response
+        result = {"max_mtime": max_mtime}
+        serializer = self.get_serializer(result)
+        return Response(serializer.data)

codex/views/browser/order_by.py

@@ -6,7 +6,6 @@ from codex.models import Comic
 from codex.views.browser.filters.annotations import (
     BrowserAnnotationsFilterView,
 )
-from codex.views.const import FOLDER_GROUP
 
 
 class BrowserOrderByView(BrowserAnnotationsFilterView):
@@ -14,11 +13,7 @@ class BrowserOrderByView(BrowserAnnotationsFilterView):
 
     def set_order_key(self):
         """Get the default order key for the view."""
-        order_key: str = self.params.get("order_by", "")  # type: ignore
-        if not order_key:
-            group = self.kwargs.get("group")
-            order_key = "filename" if group == FOLDER_GROUP else "sort_name"
-        self.order_key: str = order_key
+        self.order_key: str = self.params["order_by"]
         order_reverse = self.params.get("order_reverse")
         self.order_agg_func = Max if order_reverse else Min
 

codex/views/browser/settings.py

@@ -1,6 +1,7 @@
 """Browser session view."""
 
 from codex.serializers.browser.settings import BrowserSettingsSerializer
+from codex.views.const import GROUP_ORDER
 from codex.views.settings import SettingsView
 
 
@@ -11,3 +12,55 @@ class BrowserSettingsView(SettingsView):
     serializer_class = BrowserSettingsSerializer  # type: ignore
 
     SESSION_KEY = SettingsView.BROWSER_SESSION_KEY
+
+    @staticmethod
+    def _strip_breadcrumb_names(params):
+        """Remove names from breadcrumbs."""
+        breadcrumbs = params.get("breadcrumbs")
+        if not breadcrumbs:
+            return params
+        nameless_breadcrumbs = []
+        for crumb in breadcrumbs:
+            crumb.pop("name", None)
+            nameless_breadcrumbs.append(crumb)
+        params["breadcrumbs"] = nameless_breadcrumbs
+        return params
+
+    @staticmethod
+    def _validate_browse_top_group(params, group, top_group):
+        """Validate top group for browse groups."""
+        show = params["show"]
+        if group == "r" or (
+            show.get(top_group)
+            and GROUP_ORDER.index(top_group) < GROUP_ORDER.index(group)
+        ):
+            return
+
+        for show_group, on in show.items():
+            if on:
+                params["top_group"] = show_group
+                break
+        else:
+            params["top_group"] = "c"
+
+    @classmethod
+    def _validate_top_group(cls, params, group, top_group):
+        """Validate top group."""
+        if group == top_group:
+            return
+
+        if group in ("f", "a"):
+            params["top_group"] = group
+        else:
+            cls._validate_browse_top_group(params, group, top_group)
+
+    def validate_settings_get(self, validated_data, params):
+        """Change bad settings."""
+        top_group = params["top_group"]
+        group = validated_data.get("group", "r") if validated_data else "r"
+        self._validate_top_group(params, group, top_group)
+
+        if not validated_data.get("breadcrumb_names", True):
+            params = self._strip_breadcrumb_names(params)
+
+        return params

codex/views/browser/validate.py

@@ -15,6 +15,7 @@ from codex.views.const import (
 )
 
 LOG = get_logger(__name__)
+_NO_TOP_GROUP_VALIDATE = frozenset({"metadata"})
 
 
 class BrowserValidateView(BrowserBaseView):
@@ -55,6 +56,8 @@ class BrowserValidateView(BrowserBaseView):
         return valid_top_groups
 
     def _validate_top_group(self, valid_top_groups):
+        # if self.TARGET in _NO_TOP_GROUP_VALIDATE:
+        #    return
         nav_group = self.kwargs.get("group")
         top_group = self.params.get("top_group")
         if top_group not in valid_top_groups:

codex/views/const.py

@@ -1,9 +1,12 @@
 """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,
@@ -64,6 +67,25 @@ GROUP_RELATION = MappingProxyType(
         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(
     {
@@ -95,8 +117,12 @@ GROUP_MODELS = (
     Imprint,
     Series,
     Volume,
-    Comic,
     Folder,
+    StoryArc,
+)
+STATS_GROUP_MODELS = (
+    *GROUP_MODELS,
+    Comic,
 )
 METADATA_MODELS = (
     AgeRating,
@@ -127,3 +153,8 @@ CONFIG_MODELS = (
 )
 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_DATETIMEFILED = Value(EPOCH_START)

codex/views/opds/v1/feed.py

@@ -11,10 +11,10 @@ from rest_framework.throttling import ScopedRateThrottle
 from codex.librarian.importer.tasks import LazyImportComicsTask
 from codex.librarian.mp_queue import LIBRARIAN_QUEUE
 from codex.logger.logging import get_logger
+from codex.serializers.browser.settings import OPDSSettingsSerializer
 from codex.serializers.opds.v1 import (
     OPDS1TemplateSerializer,
 )
-from codex.views.browser.browser import BrowserView
 from codex.views.const import FALSY, MAX_OBJ_PER_PAGE
 from codex.views.opds.auth import OPDSTemplateView
 from codex.views.opds.const import BLANK_TITLE, MimeType
@@ -56,6 +56,7 @@ class OPDS1FeedView(OPDS1LinksView, OPDSTemplateView):
 
     template_name = "opds_v1/index.xml"
     serializer_class = OPDS1TemplateSerializer
+    input_serializer_class = OPDSSettingsSerializer
     throttle_classes = (ScopedRateThrottle,)
     throttle_scope = "opds"
     TARGET = "opds1"
@@ -254,10 +255,7 @@ class OPDS1FeedView(OPDS1LinksView, OPDSTemplateView):
         self._set_user_agent_variables()
         self.skip_order_facets |= self.kwargs.get("group") == "c"
 
-    @extend_schema(
-        request=BrowserView.input_serializer_class,
-        parameters=[BrowserView.input_serializer_class],
-    )
+    @extend_schema(parameters=[input_serializer_class])
     def get(self, *_args, **_kwargs):
         """Get the feed."""
         self.init_request()

codex/views/opds/v2/feed.py

@@ -7,8 +7,8 @@ from rest_framework.response import Response
 
 from codex.logger.logging import get_logger
 from codex.models import AdminFlag
+from codex.serializers.browser.settings import OPDSSettingsSerializer
 from codex.serializers.opds.v2 import OPDS2FeedSerializer
-from codex.views.browser.browser import BrowserView
 from codex.views.const import FALSY, MAX_OBJ_PER_PAGE
 from codex.views.opds.auth import OPDSAuthMixin
 from codex.views.opds.const import BLANK_TITLE
@@ -36,6 +36,7 @@ class OPDS2FeedView(OPDSAuthMixin, OPDS2PublicationView):
     throttle_scope = "opds"
 
     serializer_class = OPDS2FeedSerializer
+    input_serializer_class = OPDSSettingsSerializer
 
     def _title(self, browser_title):
         """Create the feed title."""
@@ -233,8 +234,7 @@ class OPDS2FeedView(OPDSAuthMixin, OPDS2PublicationView):
         # self._detect_user_agent()
 
     @extend_schema(
-        request=BrowserView.input_serializer_class,
-        parameters=[BrowserView.input_serializer_class],
+        parameters=[input_serializer_class],
     )
     def get(self, *_args, **_kwargs):
         """Get the feed."""

codex/views/reader/arcs.py

@@ -4,7 +4,7 @@ from types import MappingProxyType
 
 from codex.models import AdminFlag
 from codex.util import max_none
-from codex.views.const import FOLDER_GROUP
+from codex.views.const import FOLDER_GROUP, STORY_ARC_GROUP
 from codex.views.reader.books import ReaderBooksView
 
 
@@ -16,6 +16,22 @@ class ReaderArcsView(ReaderBooksView):
         super().__init__(*args, **kwargs)
         self.params: MappingProxyType = MappingProxyType({})
 
+    def _get_group_arc(self, book, attr):
+        """Create the volume arc."""
+        group = getattr(book, attr, None)
+        if not group:
+            return None
+
+        _, arc_pks = self.get_group_pks_from_breadcrumbs([group])
+        if group.pk not in arc_pks:
+            arc_pks = (group.pk,)
+        return {
+            "group": attr[0],
+            "pks": arc_pks,
+            "name": group.name,
+            "mtime": group.updated_at,
+        }
+
     def _get_folder_arc(self, book):
         """Create the folder arc."""
         efv_flag = (
@@ -23,39 +39,16 @@ class ReaderArcsView(ReaderBooksView):
             .get(key=AdminFlag.FlagChoices.FOLDER_VIEW.value)
             .on
         )
+        if not efv_flag:
+            return None
 
-        if efv_flag:
-            folder = book.parent_folder
-            folder_arc = {
-                "group": FOLDER_GROUP,
-                "pks": (folder.pk,),
-                "name": folder.name,
-                "mtime": folder.updated_at,
-            }
-        else:
-            folder_arc = None
-        return folder_arc
-
-    def _get_series_arc(self, book):
-        """Create the series arc."""
-        series = book.series
-        if series:
-            arc_pks = self.get_series_pks_from_breadcrumbs()
-            if book.series.pk not in arc_pks:
-                arc_pks = (book.series.pk,)
-            arc = (
-                {
-                    "group": "s",
-                    "pks": arc_pks,
-                    "name": series.name,
-                    "mtime": series.updated_at,
-                }
-                if series
-                else None
-            )
-        else:
-            arc = None
-        return arc
+        folder = book.parent_folder
+        return {
+            "group": FOLDER_GROUP,
+            "pks": (folder.pk,),
+            "name": folder.name,
+            "mtime": folder.updated_at,
+        }
 
     def _get_story_arcs(self, book):
         """Create story arcs."""
@@ -74,26 +67,24 @@ class ReaderArcsView(ReaderBooksView):
     def get_arcs(self, book):
         """Get all series/folder/story arcs."""
         # create top arcs
-        folder_arc = self._get_folder_arc(book)
-        series_arc = self._get_series_arc(book)
-
-        # order top arcs
+        arcs = []
         top_group = self.params.get("top_group")
-        if top_group == FOLDER_GROUP and folder_arc:
-            arc = folder_arc
-            other_arc = series_arc
-        else:
+        arc = None
+        if series_arc := self._get_group_arc(book, "series"):
+            arcs.append(series_arc)
             arc = series_arc
-            other_arc = folder_arc
-
-        arcs = []
-        arcs.append(arc)
-        if other_arc:
-            arcs.append(other_arc)
-
-        # story arcs
-        sas = self._get_story_arcs(book)
-        arcs += sas
+        if volume_arc := self._get_group_arc(book, "volume"):
+            arcs.append(volume_arc)
+            if not arc:
+                arc = volume_arc
+        if folder_arc := self._get_folder_arc(book):
+            arcs.append(folder_arc)
+            if top_group == FOLDER_GROUP:
+                arc = folder_arc
+        if story_arcs := self._get_story_arcs(book):
+            arcs = [*arcs, *story_arcs]
+            if top_group == STORY_ARC_GROUP:
+                arc = story_arcs[0]
 
         max_mtime = None
         for arc in arcs: