codex 1.7.2__py3-none-any.whl → 1.7.3__py3-none-any.whl

codex/views/browser/annotate/order.py

@@ -9,7 +9,7 @@ from django.db.models import (
     Q,
     Value,
 )
-from django.db.models.aggregates import Avg, Max, Min, Sum
+from django.db.models.aggregates import Avg, Count, Max, Min, Sum
 from django.db.models.fields import CharField
 from django.db.models.functions import Reverse, Right, StrIndex
 
@@ -33,6 +33,7 @@ _ORDER_AGGREGATE_FUNCS = MappingProxyType(
     # These are annotated to order_value because they're simple relations
     {
         "age_rating": Avg,
+        "child_count": Min,
         "community_rating": Avg,
         "created_at": Min,
         "critical_rating": Avg,
@@ -45,10 +46,11 @@ _ORDER_AGGREGATE_FUNCS = MappingProxyType(
 _ANNOTATED_ORDER_FIELDS = frozenset(
     # These are annotated with their own functions
     {
+        "bookmark_updated_at",
+        "child_count",
         "filename",
-        "sort_name",
         "search_score",
-        "bookmark_updated_at",
+        "sort_name",
         "story_arc_number",
     }
 )
@@ -71,6 +73,7 @@ class BrowserAnnotateOrderView(BrowserOrderByView, SharedAnnotationsMixin):
         self._is_opds_acquisition: bool | None = None
         self._opds_acquisition_groups: frozenset[str] | None = None
         self.bmua_is_max = False
+        self._child_count_annotated = False
 
     @property
     def opds_acquisition_groups(self):
@@ -109,13 +112,11 @@ class BrowserAnnotateOrderView(BrowserOrderByView, SharedAnnotationsMixin):
             qs.model is StoryArc and self.order_key == "story_arc_number"
         ):
             return qs
+        group = self.kwargs.get("group")
         pks = self.kwargs.get("pks")
-        show = MappingProxyType(self.params["show"])  # type: ignore
-        # TODO too many annotations for order?
-        #   Move other annotations to card.
-        #   eager publisher for imprint of course
+        show = MappingProxyType(self.params["show"])
         sort_name_annotations = self.get_sort_name_annotations(
-            qs.model, self.model_group, pks, show
+            qs.model, group, pks, show
         )
         if sort_name_annotations:
             qs = qs.alias(**sort_name_annotations)
@@ -130,7 +131,11 @@ class BrowserAnnotateOrderView(BrowserOrderByView, SharedAnnotationsMixin):
 
         return Right(
             path_rel,
-            StrIndex(Reverse(F(path_rel)), Value(sep)) - 1,  # type: ignore
+            StrIndex(
+                Reverse(F(path_rel)),  # type: ignore[reportArgumentType]
+                Value(sep),
+            )
+            - 1,
             output_field=CharField(),
         )
 
@@ -155,9 +160,7 @@ class BrowserAnnotateOrderView(BrowserOrderByView, SharedAnnotationsMixin):
         if group == STORY_ARC_GROUP and pks:
             story_arc_pks = pks
         else:
-            story_arc_pks = self.params.get("filters", {}).get(  # type: ignore
-                "story_arcs", ()
-            )
+            story_arc_pks = self.params.get("filters", {}).get("story_arcs", ())
 
         # If we have one annotate it.
         if story_arc_pks:
@@ -202,6 +205,35 @@ class BrowserAnnotateOrderView(BrowserOrderByView, SharedAnnotationsMixin):
         # This is used by the serializer to compute mtime
         return qs.annotate(bmua_is_max=Value(self.bmua_is_max))
 
+    def _annotate_search_scores(self, qs):
+        """Annotate Search Scores."""
+        if (
+            self.TARGET not in self._COVER_AND_CARD_TARGETS
+            or self.order_key != "search_score"
+        ):
+            return qs
+
+        # Rank is always the max of the relations, cannot aggregate?
+        # group by here fixes duplicates with story_arc, probably because it's a long relation
+        return qs.annotate(search_score=ComicFTSRank()).group_by("id")
+
+    def annotate_child_count(self, qs):
+        """Annotate child count."""
+        if qs.model is Comic or self._child_count_annotated:
+            return qs
+        rel = self.rel_prefix + "pk"
+        count_func = Count(rel, distinct=True)
+        ann = {"child_count": count_func}
+        qs = qs.alias(**ann) if self.TARGET == "opds2" else qs.annotate(**ann)
+        self._child_count_annotated = True
+        return qs
+
+    def _annotate_order_child_count(self, qs):
+        """Annotate child count for order."""
+        if self.order_key != "child_count":
+            return qs
+        return self.annotate_child_count(qs)
+
     def annotate_order_value(self, qs):
         """Annotate a main key for sorting and browser card display."""
         # Determine order func
@@ -209,7 +241,12 @@ class BrowserAnnotateOrderView(BrowserOrderByView, SharedAnnotationsMixin):
             return qs
         if qs.model is Folder and self.order_key == "filename":
             order_value = F("name")
-        elif qs.model is Comic or self.order_key in _ANNOTATED_ORDER_FIELDS:
+        elif qs.model is Comic:
+            order_key = (
+                "sort_name" if self.order_key == "child_count" else self.order_key
+            )
+            order_value = F(order_key)
+        elif self.order_key in _ANNOTATED_ORDER_FIELDS:
             # These are annotated in browser_annotaions
             order_value = F(self.order_key)
         else:
@@ -224,18 +261,6 @@ class BrowserAnnotateOrderView(BrowserOrderByView, SharedAnnotationsMixin):
             qs = qs.alias(order_value=order_value)
         return qs
 
-    def _annotate_search_scores(self, qs):
-        """Annotate Search Scores."""
-        if (
-            self.TARGET not in self._COVER_AND_CARD_TARGETS
-            or self.order_key != "search_score"
-        ):
-            return qs
-
-        # Rank is always the max of the relations, cannot aggregate?
-        # group by here fixes duplicates with story_arc, probably because it's a long relation
-        return qs.annotate(search_score=ComicFTSRank()).group_by("id")
-
     def annotate_order_aggregates(self, qs):
         """Annotate common aggregates between browser and metadata."""
         qs = qs.annotate(ids=JsonGroupArray("id", distinct=True))
@@ -245,6 +270,7 @@ class BrowserAnnotateOrderView(BrowserOrderByView, SharedAnnotationsMixin):
         qs = self._alias_story_arc_number(qs)
         qs = self._annotate_page_count(qs)
         qs = self._annotate_bookmark_updated_at(qs)
+        qs = self._annotate_order_child_count(qs)
         if qs.model is not Comic:
             # comic orders on indexed fields when it can
             qs = self.annotate_order_value(qs)

codex/views/browser/bookmark.py

@@ -0,0 +1,53 @@
+"""Bookmark view."""
+
+from drf_spectacular.utils import extend_schema
+from rest_framework.response import Response
+
+from codex.librarian.bookmark.update import BookmarkUpdate
+from codex.logger.logging import get_logger
+from codex.models.comic import Comic
+from codex.serializers.models.bookmark import (
+    BookmarkFinishedSerializer,
+    BookmarkSerializer,
+)
+from codex.views.bookmark import BookmarkAuthMixin
+from codex.views.browser.filters.filter import BrowserFilterView
+
+LOG = get_logger(__name__)
+
+
+class BookmarkView(BookmarkUpdate, BookmarkAuthMixin, BrowserFilterView):
+    """User Bookmark View."""
+
+    serializer_class = BookmarkSerializer
+
+    def _parse_params(self):
+        """Validate and translate the submitted data."""
+        group = self.kwargs.get("group")
+        # If the target is recursive, strip everything but finished state data.
+        serializer_class = None if group == "c" else BookmarkFinishedSerializer
+
+        data = self.request.data
+        if serializer_class:
+            serializer = serializer_class(data=data, partial=True)
+        else:
+            serializer = self.get_serializer(data=data, partial=True)
+        serializer.is_valid(raise_exception=True)
+        return serializer.validated_data
+
+    def _get_comic_query(self):
+        """Get comic pks for group."""
+        group = self.kwargs.get("group")
+        pks = self.kwargs.get("pks")
+        return self.get_filtered_queryset(Comic, group=group, pks=pks).only("pk")
+
+    @extend_schema(request=serializer_class, responses=None)
+    def patch(self, *_args, **_kwargs):
+        """Update bookmarks recursively."""
+        updates = self._parse_params()
+
+        auth_filter = self.get_bookmark_auth_filter()
+        comic_qs = self._get_comic_query()
+
+        self.update_bookmarks(auth_filter, comic_qs, updates, LOG)
+        return Response()

codex/views/browser/breadcrumbs.py

@@ -87,8 +87,9 @@ class BrowserBreadcrumbsView(BrowserPaginateView):
                 if not model:
                     model = Publisher
                 group_query = model.objects.none()
-            self._group_instance = group_query.first()
-        return self._group_instance  # type: ignore
+            group_instance: BrowserGroupModel | None = group_query.first()
+            self._group_instance = group_instance
+        return self._group_instance  # type: ignore[reportReturnType]
 
     def _init_breadcrumbs(self, valid_groups):
         """Load breadcrumbs and determine if they should be searched for a graft."""
@@ -103,7 +104,7 @@ class BrowserBreadcrumbsView(BrowserPaginateView):
         """Save the breadcrumbs to params."""
         params = dict(self.params)
         params["breadcrumbs"] = tuple(crumb.dict() for crumb in breadcrumbs)
-        # HACK rewriting params
+        # The only place I rewrite params
         self._params = MappingProxyType(params)
 
     def _breadcrumbs_graft_or_create_story_arc(self) -> tuple[tuple[Route, ...], bool]:
@@ -146,7 +147,7 @@ class BrowserBreadcrumbsView(BrowserPaginateView):
 
         pks = self.kwargs["pks"]
         page = self.kwargs["page"]
-        folder: Folder | None = self.group_instance  # type: ignore
+        folder: Folder | None = self.group_instance  # type: ignore[reportAssignmentType]
         name = folder.name if folder and pks else ""
         group_crumb = Route(FOLDER_GROUP, pks, page, name)
         new_breadcrumbs = []
@@ -230,7 +231,7 @@ class BrowserBreadcrumbsView(BrowserPaginateView):
         """Graft or create browse group breadcrumbs."""
         old_breadcrumbs, changed = self._init_breadcrumbs(GROUP_ORDER)
 
-        vng = self.valid_nav_groups  # type: ignore
+        vng = self.valid_nav_groups
         test_groups = tuple(reversed(vng[:-1]))
         new_breadcrumbs = []
         level = done = False

codex/views/browser/browser.py

@@ -173,13 +173,13 @@ class BrowserView(BrowserTitleView):
         else:
             zero_pad = 1
 
-        # self._debug_queries(page_group_count, page_book_count, group_qs, book_qs)
+        # self._debug_queries(page_group_count, page_book_count, group_qs, book_qs) # noqa: ERA001
 
         total_page_count = page_group_count + page_book_count
         mtime = self._get_page_mtime()
         return group_qs, book_qs, num_pages, total_page_count, zero_pad, mtime
 
-    def get_object(self):  # type: ignore
+    def get_object(self):
         """Validate settings and get the querysets."""
         group_qs, book_qs, num_pages, total_count, zero_pad, mtime = (
             self._get_group_and_books()

codex/views/browser/choices.py

@@ -98,7 +98,7 @@ class BrowserChoicesViewBase(BrowserFilterView):
 
         return rel, model
 
-    def get_object(self) -> QuerySet:  # type: ignore
+    def get_object(self) -> QuerySet:
         """Get the comic subquery use for the choices."""
         return self.get_filtered_queryset(Comic)
 
@@ -136,12 +136,13 @@ class BrowserChoicesAvailableView(BrowserChoicesViewBase):
 
         return count
 
-    def get_object(self) -> dict[str, Any]:  # type: ignore
+    def get_object(self) -> dict[str, Any]:  # type: ignore[reportIncompatibleMethodOverride]
         """Get choice counts."""
         qs = super().get_object()
         filters = self.params.get("filters", {})
         data = {}
-        for field_name in self.serializer_class().get_fields():  # type: ignore
+        serializer: BrowserFilterChoicesSerializer = self.serializer_class()  # type: ignore[reportOptionalCall, reportAssignmentType]
+        for field_name in serializer.get_fields():
             if field_name == "story_arcs" and qs.model is StoryArc:
                 # don't allow filtering on story arc in story arc view.
                 continue
@@ -154,7 +155,7 @@ class BrowserChoicesAvailableView(BrowserChoicesViewBase):
 
             try:
                 is_filter_set = bool(filters.get(field_name))
-                flag = is_filter_set or count > 1  # type: ignore
+                flag = is_filter_set or count > 1
             except TypeError:
                 flag = False
             data[field_name] = flag
@@ -185,7 +186,7 @@ class BrowserChoicesView(BrowserChoicesViewBase):
         field_name = self.kwargs.get("field_name", "")
         return snakecase(field_name)
 
-    def get_object(self) -> dict[str, Any]:  # type: ignore
+    def get_object(self) -> dict[str, Any]:  # type: ignore[reportIncompatibleMethodOverride]
         """Return choices with more than one choice."""
         qs = super().get_object()
         field_name = self._get_field_name()

codex/views/browser/cover.py

@@ -52,7 +52,7 @@ class CoverView(BrowserAnnotateOrderView):
         BrowserAnnotateOrderView.REPARSE_JSON_FIELDS | {"parent"}
     )
 
-    def get_group_filter(self, group=None, pks=None, page_mtime=False):
+    def get_group_filter(self, group=None, pks=None, page_mtime=False):  # noqa: FBT002
         """Get group filter for First Cover View."""
         if self.params.get("dynamic_covers") or self.model in (Volume, Folder):
             return super().get_group_filter(group=group, pks=pks, page_mtime=page_mtime)
@@ -60,7 +60,10 @@ class CoverView(BrowserAnnotateOrderView):
         # 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"]
-        qs = self.model.objects.filter(pk__in=pks)  # type: ignore
+        if not self.model:
+            qs = Comic.objects.none()
+        else:
+            qs = self.model.objects.filter(pk__in=pks)
         sort_names = qs.values_list("sort_name", flat=True).distinct()
         model_rel = GROUP_RELATION[self.model_group]
         group_filter = {f"{model_rel}__sort_name__in": sort_names}
@@ -142,7 +145,7 @@ class CoverView(BrowserAnnotateOrderView):
         parameters=[BrowserAnnotateOrderView.input_serializer_class],
         responses={(200, content_type): OpenApiTypes.BINARY},
     )
-    def get(self, *args, **kwargs):  # type: ignore
+    def get(self, *args, **kwargs):
         """Get comic cover."""
         try:
             try:

codex/views/browser/download.py

@@ -54,11 +54,14 @@ class GroupDownloadView(BrowserFilterView):
         filename = kwargs.get("filename")
         if not filename:
             pks = self.kwargs.get("pks")
-            filename = f"{self.model.__name__} {pks} Comics.zip"  # type: ignore
+            name = self.model.__name__ if self.model else "No Model"
+            filename = f"{name} {pks} Comics.zip"
 
+        headers = {"Content-Length": len(zs), "Last-Modified": zs.last_modified}
         return FileResponse(
             download_file,
             as_attachment=self.AS_ATTACHMENT,
             content_type=self.content_type,
             filename=filename,
+            headers=headers,
         )

codex/views/browser/filters/bookmark.py

@@ -1,48 +1,20 @@
 """Bookmark filter view methods."""
 
-from typing import TYPE_CHECKING
-
 from django.db.models import Q
 
+from codex.views.bookmark import BookmarkFilterMixin
 from codex.views.browser.validate import BrowserValidateView
 
-if TYPE_CHECKING:
-    from codex.models import BrowserGroupModel
-
 
-class BrowserFilterBookmarkView(BrowserValidateView):
+class BrowserFilterBookmarkView(BookmarkFilterMixin, BrowserValidateView):
     """BookmarkFilter view methods."""
 
-    def __init__(self, *args, **kwargs):
-        """Initialize the bm_annotation_data."""
-        super().__init__(*args, **kwargs)
-        self._bm_rels: dict[BrowserGroupModel, str] = {}
-        self._bm_filters: dict[BrowserGroupModel, Q] = {}
-
-    def _get_bm_rel(self, model):
-        """Create bookmark relation."""
-        if model not in self._bm_rels:
-            rel_prefix = self.get_rel_prefix(model)  # type: ignore
-            self._bm_rels[model] = rel_prefix + "bookmark"
-        return self._bm_rels[model]
-
-    def _get_my_bookmark_filter(self, bm_rel):
-        """Get a filter for my session or user defined bookmarks."""
-        if self.request.user and self.request.user.is_authenticated:
-            key = f"{bm_rel}__user"
-            value = self.request.user
-        else:
-            key = f"{bm_rel}__session__session_key"
-            value = self.request.session.session_key
-        my_bookmarks_kwargs = {key: value}
-        return Q(**my_bookmarks_kwargs)
-
     def get_bookmark_filter(self, model):
         """Build bookmark query."""
-        choice: str = self.params.get("filters", {}).get("bookmark", "")  # type: ignore
+        choice: str = self.params.get("filters", {}).get("bookmark", "")
         if choice:
-            bm_rel = self._get_bm_rel(model)
-            my_bookmark_filter = self._get_my_bookmark_filter(bm_rel)
+            bm_rel = self.get_bm_rel(model)
+            my_bookmark_filter = self.get_my_bookmark_filter(bm_rel)
             if choice == "READ":
                 bookmark_filter = my_bookmark_filter & Q(
                     **{f"{bm_rel}__finished": True}

codex/views/browser/filters/field.py

@@ -55,5 +55,5 @@ class ComicFieldFilterView(GroupFilterView):
     def get_comic_field_filter(self, model):
         """Filter the comics based on the form filters."""
         rel_prefix = self.get_rel_prefix(model)
-        filters = self.params["filters"]  # type: ignore
+        filters = self.params["filters"]
         return self.get_all_comic_field_filters(rel_prefix, filters)

codex/views/browser/filters/filter.py

@@ -13,8 +13,6 @@ LOG = get_logger(__name__)
 class BrowserFilterView(BrowserFilterBookmarkView):
     """Browser Filters."""
 
-    TARGET = ""
-
     def force_inner_joins(self, qs):
         """Force INNER JOINS to filter empty groups."""
         demote_tables = {"codex_library"}
@@ -28,10 +26,10 @@ class BrowserFilterView(BrowserFilterBookmarkView):
     def _get_query_filters(
         self,
         model,
+        page_mtime,
+        bookmark_filter,
         group=None,
         pks=None,
-        page_mtime=False,
-        bookmark_filter=True,
     ) -> Q:
         """Return all the filters except the group filter."""
         big_include_filter = Q()
@@ -54,16 +52,16 @@ class BrowserFilterView(BrowserFilterBookmarkView):
         model,
         group=None,
         pks=None,
-        page_mtime=False,
-        bookmark_filter=True,
+        page_mtime=False,  # noqa: FBT002
+        bookmark_filter=True,  # noqa: FBT002
     ) -> QuerySet:
         """Get a filtered queryset for the model."""
         query_filters = self._get_query_filters(
             model,
-            group=group,
-            pks=pks,
             page_mtime=page_mtime,
             bookmark_filter=bookmark_filter,
+            group=group,
+            pks=pks,
         )
         # Distinct necissary for folder view with search
         return model.objects.filter(query_filters).distinct()

codex/views/browser/filters/group.py

@@ -18,10 +18,11 @@ class GroupFilterView(BrowserParamsView):
 
     SESSION_KEY = BrowserParamsView.BROWSER_SESSION_KEY
 
-    def _get_rel_for_pks(self, group, page_mtime=False):
+    TARGET = ""
+
+    def _get_rel_for_pks(self, group, page_mtime: bool):
         """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
+        target: str = self.TARGET
         if target in _GROUP_REL_TARGETS:
             rel = FILTER_ONLY_GROUP_RELATION[group]
         elif target in _PK_REL_TARGETS or page_mtime:
@@ -36,7 +37,7 @@ class GroupFilterView(BrowserParamsView):
         rel += "__in"
         return rel
 
-    def get_group_filter(self, group=None, pks=None, page_mtime=False):
+    def get_group_filter(self, group=None, pks=None, page_mtime=False):  # noqa: FBT002
         """Get filter for the displayed group."""
         if group is None:
             group = self.kwargs["group"]

codex/views/browser/filters/search/field/expression.py

@@ -79,8 +79,7 @@ def _cast_value(rel, rel_class, value):
         value = parse(value)
         if rel_class == DateField and value:
             value = value.date()
-    # elif rel_class in (CharField, TextField):
-    #    value = value
+    # (CharField, TextField):
     return value
 
 

codex/views/browser/filters/search/field/optimize.py

@@ -1,5 +1,5 @@
 """Optimize Text Lookups."""
-# XXX Unused XXX multiple like queries test better
+# UNUSED CODE multiple like queries test better
 
 import re
 

codex/views/browser/filters/search/field/parse.py

@@ -22,7 +22,7 @@ if TYPE_CHECKING:
     from pyparsing.helpers import InfixNotationOperatorSpec
 
 _QUOTES_REXP = r"(?:\".*?\")"
-_OPERATORS_REXP = "|".join(("and not", "or not", "and", "or"))
+_OPERATORS_REXP = "and not|or not|and|or"
 _BEGIN_NOT_REXP = r"^\s*\(?\s*(?P<not>not)"
 _IMPLICIT_AND_REXP = (
     rf"{_QUOTES_REXP}|\ (?P<ok>{_OPERATORS_REXP})\ |(?P<bare>(?:\ not)?\ )\S"
@@ -183,5 +183,5 @@ def get_field_query(rel, rel_class, exp, model, many_to_many):
     bool_expr = _create_context_expression(context)
 
     parsed_result = bool_expr.parse_string(exp)
-    root_bool_operand: BoolOperand = parsed_result[0]  # type:ignore
+    root_bool_operand: BoolOperand = parsed_result[0]  # type:ignore[reportAssignmentType]
     return root_bool_operand.to_query()

codex/views/browser/filters/search/parse.py

@@ -149,7 +149,7 @@ class SearchFilterView(BrowserFTSFilter):
 
     def _preparse_search_query(self):
         """Preparse search fields out of query text."""
-        text = self.params.get("q")  # type: ignore
+        text = self.params.get("q")
         field_tokens = {}
         if not text:
             return field_tokens, text
@@ -177,7 +177,7 @@ class SearchFilterView(BrowserFTSFilter):
                 )
             else:
                 # AND and OR
-                # XXX cannot do OR queries with MATCH, it decontextualizes MATCH somehow.
+                # Cannot do OR queries with MATCH, it decontextualizes MATCH somehow.
                 if preop == "or":
                     self.search_error = "OR preceding column tokens with operator expressions will act as AND"
                 include_q_list, exclude_q_list = self.get_search_field_filters(
@@ -227,24 +227,9 @@ class SearchFilterView(BrowserFTSFilter):
 
         return include_q, exclude_q, fts_q
 
-    def _is_search_results_limited(self) -> bool:
-        """Get search result limit from params."""
-        # user = self.request.user  # type: ignore
-        # if user and user.is_authenticated:
-        #    limited = bool(
-        #        self.params.get(  # type: ignore
-        #            "search_results_limit",
-        #            MAX_OBJ_PER_PAGE,
-        #        )
-        #    )
-        # else:
-        #    limited = True
-        # return limited
-        return True
-
     def get_search_limit(self):
         """Get search scores for choices and metadata."""
-        if not self.search_mode or not self._is_search_results_limited():
+        if not self.search_mode:
             return 0
-        page = self.kwargs.get("page", 1)  # type: ignore
+        page = self.kwargs.get("page", 1)
         return page * MAX_OBJ_PER_PAGE + 1

codex/views/browser/group_mtime.py

@@ -46,15 +46,15 @@ class BrowserGroupMtimeView(BrowserFilterView):
         self, model, agg_func: type[Aggregate] = Max, default=NONE_DATETIMEFIELD
     ):
         """Get filtered maximum bookmark updated_at relation."""
-        bm_rel = self._get_bm_rel(model)
-        bm_filter = self._get_my_bookmark_filter(bm_rel)
+        bm_rel = self.get_bm_rel(model)
+        bm_filter = self.get_my_bookmark_filter(bm_rel)
         bmua_rel = f"{bm_rel}__updated_at"
         args = {"default": default, "filter": bm_filter}
         if agg_func is JsonGroupArray:
             args["distinct"] = True
         return agg_func(bmua_rel, **args)
 
-    def get_group_mtime(self, model, group=None, pks=None, page_mtime=False):
+    def get_group_mtime(self, model, group=None, pks=None, page_mtime=False):  # noqa: FBT002
         """Get a filtered mtime for browser pages and mtime checker."""
         qs = self.get_filtered_queryset(
             model,

codex/views/browser/metadata/annotate.py

@@ -86,7 +86,7 @@ class MetadataAnnotateView(BrowserAnnotateCardView):
 
         return filtered_qs, qs
 
-    def _annotate_values_and_fks(self, qs, filtered_qs):
+    def annotate_values_and_fks(self, qs, filtered_qs):
         """Annotate comic values and comic foreign key values."""
         # Simple Values
         querysets = (filtered_qs, qs)

codex/views/browser/metadata/copy_intersections.py

@@ -47,7 +47,7 @@ class MetadataCopyIntersectionsView(MetadataQueryIntersectionsView):
     @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.
+        # 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}"

codex/views/browser/metadata/metadata.py

@@ -54,7 +54,7 @@ class MetadataView(MetadataCopyIntersectionsView):
         # Annotate
         qs = self.annotate_order_aggregates(qs)
         qs = self.annotate_card_aggregates(qs)
-        qs = self._annotate_values_and_fks(qs, filtered_qs)
+        qs = self.annotate_values_and_fks(qs, filtered_qs)
         qs = self.add_group_by(qs)
         qs = self.force_inner_joins(qs)
 
@@ -63,7 +63,7 @@ class MetadataView(MetadataCopyIntersectionsView):
             obj = qs[0]
             if not obj:
                 reason = "Empty obj"
-                raise ValueError(reason)  # noqa TRY301
+                raise ValueError(reason)  # noqa: TRY301
         except (IndexError, ValueError) as exc:
             return self._raise_not_found(exc)
 

codex/views/browser/mtime.py

@@ -37,7 +37,7 @@ class MtimeView(BrowserGroupMtimeView):
         """Get max mtime for all groups."""
         max_mtime = None
 
-        for item in self.params["groups"]:  # type: ignore
+        for item in self.params["groups"]:
             mtime = self._get_group_mtime(item)
             max_mtime = max_none(max_mtime, mtime)
         return max_mtime