codex 1.6.19__py3-none-any.whl → 1.7.0__py3-none-any.whl

codex/views/browser/breadcrumbs.py

@@ -2,18 +2,94 @@
 
 from contextlib import suppress
 from types import MappingProxyType
+from typing import TYPE_CHECKING
 
 from codex.logger.logging import get_logger
+from codex.models import (
+    BrowserGroupModel,
+    Comic,
+    Imprint,
+    Volume,
+)
+from codex.models.groups import Publisher
 from codex.views.browser.paginate import BrowserPaginateView
-from codex.views.const import FOLDER_GROUP, GROUP_NAME_MAP, GROUP_ORDER, STORY_ARC_GROUP
+from codex.views.const import (
+    FOLDER_GROUP,
+    GROUP_MODEL_MAP,
+    GROUP_NAME_MAP,
+    GROUP_ORDER,
+    STORY_ARC_GROUP,
+)
 from codex.views.util import Route
 
+if TYPE_CHECKING:
+    from codex.models.groups import Folder
+
 LOG = get_logger(__name__)
+_GROUP_INSTANCE_SELECT_RELATED: MappingProxyType[
+    type[BrowserGroupModel], tuple[str | None, ...]
+] = MappingProxyType(
+    {
+        Comic: ("series", "volume"),
+        Volume: ("series",),
+        Imprint: ("publisher",),
+    }
+)
 
 
 class BrowserBreadcrumbsView(BrowserPaginateView):
     """Browser breadcrumbs calculations."""
 
+    def __init__(self, *args, **kwargs):
+        """Set params for the type checker."""
+        super().__init__(*args, **kwargs)
+        self._group_instance: BrowserGroupModel | None | int = 0
+
+    def _get_group_query(self, model):
+        """Get the group query for the group instance."""
+        pks = self.kwargs.get("pks")
+        qs = model.objects.filter(pk__in=pks)
+        if select_related := _GROUP_INSTANCE_SELECT_RELATED.get(model):
+            qs = qs.select_related(*select_related)
+        order_by = "name" if model is Volume else "sort_name"
+        return qs.order_by(order_by)
+
+    def _handle_group_query_missing_model(self, model):
+        """Handle a missing model for the group instance."""
+        group = self.kwargs.get("group")
+        pks = self.kwargs.get("pks")
+        page = self.kwargs.get("page")
+        if group == "r" and not pks and page == 1:
+            group_query = model.objects.none()
+        else:
+            reason = f"{group}__in={pks} does not exist!"
+            settings_mask = {"breadcrumbs": []}
+            self.raise_redirect(
+                reason,
+                route_mask={"group": group},
+                settings_mask=settings_mask,
+            )
+        return group_query
+
+    @property
+    def group_instance(self) -> BrowserGroupModel | None:
+        """Memoize group instance for getting group names & counts."""
+        if self._group_instance == 0:
+            group = self.kwargs.get("group")
+            model = GROUP_MODEL_MAP[group]
+            pks = self.kwargs.get("pks")
+            if model and pks and 0 not in pks:
+                try:
+                    group_query = self._get_group_query(model)
+                except model.DoesNotExist:
+                    group_query = self._handle_group_query_missing_model(model)
+            else:
+                if not model:
+                    model = Publisher
+                group_query = model.objects.none()
+            self._group_instance = group_query.first()
+        return self._group_instance  # type: ignore
+
     def _init_breadcrumbs(self, valid_groups):
         """Load breadcrumbs and determine if they should be searched for a graft."""
         breadcrumbs: list[Route] = list(self.params.get("breadcrumbs", []))
@@ -27,7 +103,8 @@ class BrowserBreadcrumbsView(BrowserPaginateView):
         """Save the breadcrumbs to params."""
         params = dict(self.params)
         params["breadcrumbs"] = tuple(crumb.dict() for crumb in breadcrumbs)
-        self.params = MappingProxyType(params)
+        # HACK rewriting params
+        self._params = MappingProxyType(params)
 
     def _breadcrumbs_graft_or_create_story_arc(self) -> tuple[tuple[Route, ...], bool]:
         """Graft or create story_arc breadcrumbs."""
@@ -35,7 +112,7 @@ class BrowserBreadcrumbsView(BrowserPaginateView):
 
         pks = self.kwargs["pks"]
         page = self.kwargs["page"]
-        gi = self.group_instance  # type: ignore
+        gi = self.group_instance
         name = gi.name if gi else ""
         group_crumb = Route(STORY_ARC_GROUP, pks, page, name)
 
@@ -69,7 +146,7 @@ class BrowserBreadcrumbsView(BrowserPaginateView):
 
         pks = self.kwargs["pks"]
         page = self.kwargs["page"]
-        folder = self.group_instance  # type: ignore
+        folder: Folder | None = self.group_instance  # type: ignore
         name = folder.name if folder and pks else ""
         group_crumb = Route(FOLDER_GROUP, pks, page, name)
         new_breadcrumbs = []
@@ -91,11 +168,13 @@ class BrowserBreadcrumbsView(BrowserPaginateView):
             # parent next
             if not folder:
                 break
-            folder = folder.parent_folder
-            if folder:
-                group_crumb = Route(FOLDER_GROUP, (folder.pk,), 1, name=folder.name)
+            if folder := folder.parent_folder:
+                parent_pks = (folder.pk,)
+                parent_name = folder.name
             else:
-                group_crumb = Route(FOLDER_GROUP, (), 1, name="")
+                parent_pks = ()
+                parent_name = ""
+            group_crumb = Route(FOLDER_GROUP, parent_pks, 1, parent_name)
 
         breadcrumbs = new_breadcrumbs
 
@@ -103,16 +182,16 @@ class BrowserBreadcrumbsView(BrowserPaginateView):
 
     def _get_breadcrumbs_group_crumb(self, group):
         """Create the crumb for this group."""
-        gi = self.group_instance  # type: ignore
+        gi = self.group_instance
         if not gi:
             pks = ()
             page = 1
             name = ""
-        if group == self.kwargs["group"]:
+        elif group == self.kwargs["group"]:
             # create self crumb
             pks = self.kwargs["pks"]
             page = self.kwargs["page"]
-            name = gi.name if gi else ""
+            name = gi.name
         else:
             page = 1
             if (attr := GROUP_NAME_MAP.get(group)) and (

codex/views/browser/browser.py

@@ -1,46 +1,30 @@
 """Views for browsing comic library."""
 
-from math import floor, log10
+from math import ceil, floor, log10
 from types import MappingProxyType
-from typing import TYPE_CHECKING
 
 from django.db.models import Max
+from django.db.utils import OperationalError
 from drf_spectacular.utils import extend_schema
 from rest_framework.response import Response
 
 from codex.logger.logging import get_logger
 from codex.models import (
     AdminFlag,
-    BrowserGroupModel,
     Comic,
     Folder,
-    Imprint,
     Library,
-    Volume,
 )
 from codex.serializers.browser.page import BrowserPageSerializer
 from codex.views.browser.title import BrowserTitleView
 from codex.views.const import (
     COMIC_GROUP,
     FOLDER_GROUP,
-    NONE_DATETIMEFIELD,
+    MAX_OBJ_PER_PAGE,
     STORY_ARC_GROUP,
 )
 
-if TYPE_CHECKING:
-    from django.db.models.query import QuerySet
-
-
 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):
@@ -56,88 +40,78 @@ class BrowserView(BrowserTitleView):
     )
     TARGET = "browser"
 
-    def __init__(self, *args, **kwargs):
-        """Set params for the type checker."""
-        super().__init__(*args, **kwargs)
-        self.is_opds_2_acquisition = False
-        self.group_query: QuerySet = Comic.objects.none()
-        self.valid_nav_groups: tuple[str, ...] = ()
-
-    def _set_group_query_and_instance(self):
-        """Create group_class instance."""
-        pks = self.kwargs.get("pks")
-        if pks and self.group_class:
-            try:
-                select_related: tuple[str | None, ...] = (
-                    _GROUP_INSTANCE_SELECT_RELATED.get(self.group_class, (None,))
-                )
-                self.group_query = self.group_class.objects.select_related(
-                    *select_related
-                ).filter(pk__in=pks)
-            except self.group_class.DoesNotExist:
-                group = self.kwargs.get("group")
-                page = self.kwargs.get("page")
-                if group == "r" and not pks and page == 1:
-                    self.group_query = self.group_class.objects.none()
-                else:
-                    reason = f"{group}__in={pks} does not exist!"
-                    settings_mask = {"breadcrumbs": []}
-                    self.raise_redirect(
-                        reason, route_mask={"group": group}, settings_mask=settings_mask
-                    )
-        elif self.group_class:
-            self.group_query = self.group_class.objects.none()
-        else:
-            self.group_query = Comic.objects.none()
-        self.group_instance = self.group_query.first()
-
-    def init_request(self):
-        """Initialize request."""
-        super().init_request()
-        self._set_group_query_and_instance()
+    ########
+    # Init #
+    ########
 
-    def get_model_group(self):
+    @property
+    def model_group(self):
         """Get the group of the models to browse."""
         # the model group shown must be:
         #   A valid nav group or 'c'
         #   the child of the current nav group or 'c'
-        group = self.kwargs["group"]
-        if group == FOLDER_GROUP:
-            return group
-        if group == STORY_ARC_GROUP:
-            pks = self.kwargs.get("pks")
-            return COMIC_GROUP if pks else group
-        if group == self.valid_nav_groups[-1]:
-            # special case for lowest valid group
-            return COMIC_GROUP
-        return self.valid_nav_groups[self.valid_nav_groups.index(group) + 1]
+        if not self._model_group:
+            group = self.kwargs["group"]
+            if group == FOLDER_GROUP:
+                self._model_group = group
+            elif group == STORY_ARC_GROUP:
+                pks = self.kwargs.get("pks")
+                self._model_group = COMIC_GROUP if pks else group
+            elif group == self.valid_nav_groups[-1]:
+                # special case for lowest valid group
+                self._model_group = COMIC_GROUP
+            else:
+                self._model_group = self.valid_nav_groups[
+                    self.valid_nav_groups.index(group) + 1
+                ]
+        return self._model_group
 
     ################
     # MAIN QUERIES #
     ################
+
+    def _get_limit(self):
+        """Get the limit for the query."""
+        # query_limit only is set by some opds views
+        query_limit = self.params.get("limit", 0)
+        search_limit = self.get_search_limit()
+        if query_limit and search_limit:
+            limit = min(query_limit, search_limit)
+        else:
+            limit = max(query_limit, search_limit)
+        return limit
+
     def _get_common_queryset(self, model):
         """Create queryset common to group & books."""
         qs = self.get_filtered_queryset(model)
-        count_qs = self.add_group_by(qs, model)
-        count = count_qs.count()
+        limit = self._get_limit()
+        try:
+            count_qs = self.add_group_by(qs)
+            if limit:
+                count_qs = count_qs[:limit]
+            # Get count after filters and before any annotations or orders
+            #   because it's faster. These counts are used by
+            #   is_page_in_bounds(), num_pages for the nav bar, and paginate()
+            count = count_qs.count()
+        except OperationalError as exc:
+            self._handle_operational_error(exc)
+            count = 0
+            qs = model.objects.none()
 
         if count:
-            qs = self.annotate_order_aggregates(qs, model)
-            qs = self.add_order_by(qs, model)
-            if limit := self.params.get("limit"):
-                # limit only is set by some opds views
+            qs = self.annotate_order_aggregates(qs)
+            qs = self.add_order_by(qs)
+            if limit:
                 qs = qs[:limit]
-                count = min(count, limit)  # type: ignore
+        else:
+            qs = qs.order_by("pk")
 
         return qs, count
 
     def _get_group_queryset(self):
         """Create group queryset."""
-        if not self.model:
-            reason = "Model not set for browser queryset."
-            raise ValueError(reason)
-        elif self.is_model_comic:  # noqa: RET506
-            qs = self.model.objects.none()
+        if self.model is Comic:
+            qs = self.model.objects.none().order_by("pk")
             count = 0
         else:
             qs, count = self._get_common_queryset(self.model)
@@ -149,28 +123,10 @@ class BrowserView(BrowserTitleView):
         if self.model in (Comic, Folder):
             qs, count = self._get_common_queryset(Comic)
         else:
-            qs = Comic.objects.none()
+            qs = Comic.objects.none().order_by("pk")
             count = 0
         return qs, count
 
-    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
-
-        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):
         """Get the zero padding for the display."""
@@ -183,38 +139,47 @@ class BrowserView(BrowserTitleView):
         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
+        return self.get_group_mtime(self.model, page_mtime=True)
 
-        group_model = self.group_class if self.group_class else self.model
-        return self.get_group_mtime(group_model, page_mtime=True)
+    def _debug_queries(self, group_count, book_count, group_qs, book_qs):
+        """Log query details."""
+        if group_count:
+            LOG.debug(group_qs.explain())
+            LOG.debug(group_qs.query)
+        if book_count:
+            LOG.debug(book_qs.explain())
+            LOG.debug(book_qs.query)
 
     def _get_group_and_books(self):
         """Create the main queries with filters, annotation and pagination."""
         group_qs, group_count = self._get_group_queryset()
         book_qs, book_count = self._get_book_queryset()
+
         # Paginate
-        group_qs, book_qs, num_pages, page_group_count, page_book_count = self.paginate(
-            group_qs, book_qs, group_count, book_count
+        num_pages = ceil((group_count + book_count) / MAX_OBJ_PER_PAGE)
+        self.check_page_in_bounds(num_pages)
+        group_qs, book_qs, page_group_count, page_book_count = self.paginate(
+            group_qs, book_qs, group_count
         )
+
+        # Annotate
         if page_group_count:
-            group_qs = self.annotate_card_aggregates(group_qs, self.model)
-            group_qs = self._requery_max_bookmark_updated_at(group_qs)
+            group_qs = self.annotate_card_aggregates(group_qs)
+            group_qs = self.force_inner_joins(group_qs)
         if page_book_count:
             zero_pad = self._get_zero_pad(book_qs)
-            book_qs = self.annotate_card_aggregates(book_qs, Comic)
+            book_qs = self.annotate_card_aggregates(book_qs)
+            book_qs = self.force_inner_joins(book_qs)
         else:
             zero_pad = 1
 
-        # print(group_qs.explain())
-        # print(group_qs.query)
+        # self._debug_queries(page_group_count, page_book_count, group_qs, book_qs)
 
-        total_count = page_group_count + page_book_count
+        total_page_count = page_group_count + page_book_count
         mtime = self._get_page_mtime()
-        return group_qs, book_qs, num_pages, total_count, zero_pad, mtime
+        return group_qs, book_qs, num_pages, total_page_count, zero_pad, mtime
 
-    def get_object(self):
+    def get_object(self):  # type: ignore
         """Validate settings and get the querysets."""
         group_qs, book_qs, num_pages, total_count, zero_pad, mtime = (
             self._get_group_and_books()
@@ -226,7 +191,6 @@ class BrowserView(BrowserTitleView):
         # needs to happen after pagination
         # runs obj list query twice :/
         libraries_exist = Library.objects.filter(covers_only=False).exists()
-
         # construct final data structure
         return MappingProxyType(
             {
@@ -241,13 +205,14 @@ class BrowserView(BrowserTitleView):
                 "admin_flags": self.admin_flags,
                 "libraries_exist": libraries_exist,
                 "mtime": mtime,
+                "search_error": self.search_error,
+                "fts": self.fts_mode,
             }
         )
 
     @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)
         return Response(serializer.data)

codex/views/browser/choices.py

@@ -1,12 +1,14 @@
 """View for marking comics read and unread."""
 
 from types import MappingProxyType
+from typing import Any
 
 from caseconverter import snakecase
 from django.db.models import QuerySet
 from drf_spectacular.utils import extend_schema
 from rest_framework.response import Response
 
+from codex.choices import DUMMY_NULL_NAME, VUETIFY_NULL_CODE
 from codex.logger.logging import get_logger
 from codex.models import (
     Comic,
@@ -21,24 +23,26 @@ from codex.serializers.browser.filters import (
     BrowserFilterChoicesSerializer,
 )
 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,
+from codex.views.browser.filters.filter import BrowserFilterView
+from codex.views.session import (
+    CONTRIBUTOR_PERSON_UI_FIELD,
+    IDENTIFIER_TYPE_UI_FIELD,
+    STORY_ARC_UI_FIELD,
 )
 
 LOG = get_logger(__name__)
 
 _FIELD_TO_REL_MODEL_MAP = MappingProxyType(
     {
-        BrowserAnnotationsFilterView.CONTRIBUTOR_PERSON_UI_FIELD: (
+        CONTRIBUTOR_PERSON_UI_FIELD: (
             "contributors__person",
             ContributorPerson,
         ),
-        BrowserAnnotationsFilterView.STORY_ARC_UI_FIELD: (
+        STORY_ARC_UI_FIELD: (
             "story_arc_numbers__story_arc",
             StoryArc,
         ),
-        BrowserAnnotationsFilterView.IDENTIFIER_TYPE_UI_FIELD: (
+        IDENTIFIER_TYPE_UI_FIELD: (
             "identifiers__identifier_type",
             IdentifierType,
         ),
@@ -54,18 +58,12 @@ _BACK_REL_MAP = MappingProxyType(
 _NULL_NAMED_ROW = MappingProxyType({"pk": VUETIFY_NULL_CODE, "name": DUMMY_NULL_NAME})
 
 
-class BrowserChoicesViewBase(BrowserAnnotationsFilterView):
+class BrowserChoicesViewBase(BrowserFilterView):
     """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()
-
     @staticmethod
     def get_field_choices_query(comic_qs, field_name):
         """Get distinct values for the field."""
@@ -100,14 +98,13 @@ class BrowserChoicesViewBase(BrowserAnnotationsFilterView):
 
         return rel, model
 
-    def get_object(self):
+    def get_object(self) -> QuerySet:  # type: ignore
         """Get the comic subquery use for the choices."""
         return self.get_filtered_queryset(Comic)
 
     @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)
         return Response(serializer.data)
@@ -139,13 +136,13 @@ class BrowserChoicesAvailableView(BrowserChoicesViewBase):
 
         return count
 
-    def get_object(self):
+    def get_object(self) -> dict[str, Any]:  # type: ignore
         """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:
+            if field_name == "story_arcs" and qs.model is StoryArc:
                 # don't allow filtering on story arc in story arc view.
                 continue
             rel, m2m_model = self.get_rel_and_model(field_name)
@@ -188,7 +185,7 @@ class BrowserChoicesView(BrowserChoicesViewBase):
         field_name = self.kwargs.get("field_name", "")
         return snakecase(field_name)
 
-    def get_object(self):
+    def get_object(self) -> dict[str, Any]:  # type: ignore
         """Return choices with more than one choice."""
         qs = super().get_object()
         field_name = self._get_field_name()