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

codex/views/browser/browser.py

@@ -1,18 +1,13 @@
 """Views for browsing comic library."""
 
-from copy import deepcopy
-from math import ceil, floor, log10
-from os import sep
-from pathlib import Path
+from math import floor, log10
 from types import MappingProxyType
-from typing import TYPE_CHECKING, ClassVar
+from typing import TYPE_CHECKING
 
-from django.core.paginator import EmptyPage, Paginator
 from django.db.models import Max
 from drf_spectacular.utils import extend_schema
 from rest_framework.response import Response
 
-from codex.exceptions import SeeOtherRedirectError
 from codex.logger.logging import get_logger
 from codex.models import (
     AdminFlag,
@@ -27,10 +22,13 @@ from codex.models import (
     Volume,
 )
 from codex.serializers.browser.page import BrowserPageSerializer
-from codex.serializers.choices import DEFAULTS
-from codex.views.auth import IsAuthenticatedOrEnabledNonUsers
-from codex.views.browser.browser_breadcrumbs import BrowserBreadcrumbsView
-from codex.views.browser.const import MAX_OBJ_PER_PAGE
+from codex.util import max_none
+from codex.views.browser.title import BrowserTitleView
+from codex.views.const import (
+    COMIC_GROUP,
+    FOLDER_GROUP,
+    STORY_ARC_GROUP,
+)
 
 if TYPE_CHECKING:
     from django.db.models.query import QuerySet
@@ -39,10 +37,9 @@ if TYPE_CHECKING:
 LOG = get_logger(__name__)
 
 
-class BrowserView(BrowserBreadcrumbsView):
+class BrowserView(BrowserTitleView):
     """Browse comics with a variety of filters and sorts."""
 
-    permission_classes: ClassVar[list] = [IsAuthenticatedOrEnabledNonUsers]  # type: ignore
     serializer_class = BrowserPageSerializer
 
     ADMIN_FLAG_VALUE_KEY_MAP = MappingProxyType(
@@ -51,7 +48,7 @@ class BrowserView(BrowserBreadcrumbsView):
             AdminFlag.FlagChoices.IMPORT_METADATA.value: "import_metadata",
         }
     )
-
+    TARGET = "browser"
     _GROUP_INSTANCE_SELECT_RELATED: MappingProxyType[
         type[BrowserGroupModel], tuple[str | None, ...]
     ] = MappingProxyType(
@@ -65,45 +62,43 @@ class BrowserView(BrowserBreadcrumbsView):
             StoryArc: (None,),
         }
     )
-    DEFAULT_ROUTE = MappingProxyType(
-        {
-            "name": "browser",
-            "params": deepcopy(DEFAULTS["breadcrumbs"][0]),
-        }
-    )
-    _OPDS_M2M_RELS = (
-        "characters",
-        "genres",
-        "locations",
-        "series_groups",
-        "story_arc_numbers",
-        "story_arc_numbers__story_arc",
-        "tags",
-        "teams",
-        "contributors",
-        "contributors__role",
-        "contributors__person",
-    )
-    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.group_instance: BrowserGroupModel | None = None
         self.valid_nav_groups: tuple[str, ...] = ()
 
-    def _raise_redirect(self, reason, route_mask=None, settings_mask=None):
-        """Redirect the client to a valid group url."""
-        route = deepcopy(dict(self.DEFAULT_ROUTE))
-        if route_mask:
-            route["params"].update(route_mask)  # type: ignore
-        settings = deepcopy(dict(self.params))
-        if settings_mask:
-            settings.update(settings_mask)
-        detail = {"route": route, "settings": settings, "reason": reason}
-        raise SeeOtherRedirectError(detail=detail)
+    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, ...] = (
+                    self._GROUP_INSTANCE_SELECT_RELATED[self.group_class]
+                )
+                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!"
+                    self.raise_redirect(reason, route_mask={"group": group})
+        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()
 
     def get_model_group(self):
         """Get the group of the models to browse."""
@@ -111,21 +106,22 @@ class BrowserView(BrowserBreadcrumbsView):
         #   A valid nav group or 'c'
         #   the child of the current nav group or 'c'
         group = self.kwargs["group"]
-        if group == self.FOLDER_GROUP:
+        if group == FOLDER_GROUP:
             return group
-        if group == self.STORY_ARC_GROUP:
+        if group == STORY_ARC_GROUP:
             pks = self.kwargs.get("pks")
-            return self.COMIC_GROUP if pks else group
+            return COMIC_GROUP if pks else group
         if group == self.valid_nav_groups[-1]:
             # special case for lowest valid group
-            return self.COMIC_GROUP
+            return COMIC_GROUP
         return self.valid_nav_groups[self.valid_nav_groups.index(group) + 1]
 
+    ################
+    # MAIN QUERIES #
+    ################
     def _get_common_queryset(self, model):
         """Create queryset common to group & books."""
-        object_filter = self.get_query_filters(model, False)
-        qs = model.objects.filter(object_filter)
-        qs = self.filter_by_annotations(qs, model)
+        qs = self.get_filtered_queryset(model)
         count_group_by = self.get_group_by(model)
         count = qs.group_by(count_group_by).count()
         if count:
@@ -161,167 +157,16 @@ class BrowserView(BrowserBreadcrumbsView):
             count = 0
         return qs, count
 
-    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, ...] = (
-                    self._GROUP_INSTANCE_SELECT_RELATED[self.group_class]
-                )
-                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!"
-                    self._raise_redirect(reason, route_mask={"group": group})
-        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 _get_root_group_name(self):
-        if not self.model:
-            reason = "No model set in browser"
-            raise ValueError(reason)
-        plural = self.model._meta.verbose_name_plural
-        if not plural:
-            reason = f"No plural name for {self.model}"
-            raise ValueError(reason)
-        return plural.capitalize()
-
-    def _get_folder_parent_name(self):
-        """Get title for a folder browser page."""
-        group_instance: Folder = self.group_instance  # type: ignore
-        if not group_instance.path:
-            return ""
-
-        parent_path = Path(group_instance.path).parent
-        if not self.is_admin():
-            try:
-                # remove library path for not admins
-                library_path_parent = Path(group_instance.library.path).parent
-                parent_path = parent_path.relative_to(library_path_parent)
-            except ValueError:
-                parent_path = ""
-
-        parent_path_str = str(parent_path)
-        parent_path_str = parent_path_str.removeprefix(".")
-        if parent_path_str and parent_path_str[0] != sep:
-            parent_path_str = sep + parent_path_str
-        return parent_path_str
-
-    def _get_browser_page_title(self):
-        """Get the proper title for this browse level."""
-        group_count = 0
-        group_name = ""
-        pks = self.kwargs.get("pks")
-        if not pks:
-            group_name = self._get_root_group_name()
-        else:
-            group_instance = self.group_instance
-            if group_instance:
-                if isinstance(group_instance, Volume):
-                    group_count = group_instance.series.volume_count
-                elif isinstance(group_instance, Comic):
-                    group_count = group_instance.volume.issue_count
-                group_name = group_instance.name
-
-        return {
-            "group_name": group_name,
-            "group_count": group_count,
-        }
-
-    def _check_page_in_bounds(self, total_count):
-        """Redirect page out of bounds."""
-        pks = self.kwargs.get("pks")
-        page = self.kwargs.get("page", 1)
-        num_pages = ceil(total_count / MAX_OBJ_PER_PAGE)
-        if (not pks and page == 1) or (page >= 1 and page <= num_pages):
-            # Don't redirect if on the root page for the group.
-            # Or page within valid range.
-            return num_pages
-
-        # Adjust route mask for redirect
-        group = self.kwargs.get("group")
-        if num_pages and page > 1:
-            # Try page 1 first.
-            new_page = num_pages if num_pages and page > num_pages else 1
-            pks = pks if pks else "0"
-        else:
-            # Redirect to root for the group.
-            pks = "0"
-            new_page = 1
-
-        reason = f"{page=} does not exist!"
-        route_changes = {"group": group, "pks": pks, "page": new_page}
-        return self._raise_redirect(reason, route_mask=route_changes)
-
-    def _paginate_section(self, model, qs, page):
-        """Paginate a group or Comic section."""
-        orphans = 0 if self.model_group == "f" or self.params.get("q") else 5
-        paginator = Paginator(qs, MAX_OBJ_PER_PAGE, orphans=orphans)
-        try:
-            qs = paginator.page(page).object_list
-        except EmptyPage:
-            if model != Folder:
-                model_name = self.model.__name__ if self.model else "NO_MODEL"
-                LOG.warning(f"No {model_name}s on page {page}")
-            qs = model.objects.none()
-
-        return qs
-
-    def _paginate_groups(self, group_qs, total_group_count):
-        """Paginate the group object list before books."""
-        if total_group_count:
-            page = self.kwargs.get("page", 1)
-            page_group_qs = self._paginate_section(self.model, group_qs, page)
+    def _get_page_mtime(self, group_qs):
+        if self.group_instance:
+            page_updated_at_max = self.group_instance.updated_at
         else:
-            page_group_qs = self.model.objects.none()  # type: ignore
-        return page_group_qs
+            page_updated_at_max = group_qs.aggregate(max=Max("updated_at"))["max"]
 
-    def _paginate_books(self, book_qs, total_group_count, page_obj_count):
-        """Paginate the book object list based on how many group/folders are showing."""
-        if page_obj_count >= MAX_OBJ_PER_PAGE:
-            # No books for this page
-            page_book_qs = Comic.objects.none()
-        else:
-            group_remainder = total_group_count % MAX_OBJ_PER_PAGE
-            if page_obj_count:
-                # There are books after the groups on the same page
-                # Manually add books without the paginator
-                book_limit = MAX_OBJ_PER_PAGE - group_remainder
-                page_book_qs = book_qs[:book_limit]
-            else:
-                # There are books after the groups on a new page
-                if group_remainder:
-                    book_offset = MAX_OBJ_PER_PAGE - group_remainder
-                    page_book_qs = book_qs[book_offset:]
-                else:
-                    page_book_qs = book_qs
+        agg_func = self.get_bookmark_updated_at_aggregate(self.model, True)
+        page_bookmark_updated_at = group_qs.aggregate(max=agg_func)["max"]
 
-                num_group_and_mixed_pages = ceil(total_group_count / MAX_OBJ_PER_PAGE)
-                book_only_page = self.kwargs.get("page", 1) - num_group_and_mixed_pages
-                page_book_qs = self._paginate_section(
-                    Comic, page_book_qs, book_only_page
-                )
-        return page_book_qs
-
-    def _paginate(self, group_qs, book_qs, group_count, book_count):
-        """Paginate the queryset into a group and book object lists."""
-        num_pages = self._check_page_in_bounds(group_count + book_count)
-        page_group_qs = self._paginate_groups(group_qs, group_count)
-        page_group_count = page_group_qs.count()
-        page_book_qs = self._paginate_books(book_qs, group_count, page_group_count)
-        page_book_count = page_book_qs.count()
-
-        return page_group_qs, page_book_qs, num_pages, page_group_count, page_book_count
+        return max_none(page_updated_at_max, page_bookmark_updated_at)
 
     @staticmethod
     def _get_zero_pad(book_qs):
@@ -337,10 +182,11 @@ class BrowserView(BrowserBreadcrumbsView):
     def _get_group_and_books(self):
         """Create the main queries with filters, annotation and pagination."""
         group_qs, group_count = self._get_group_queryset()
+        mtime = self._get_page_mtime(group_qs)
         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)
+        group_qs, book_qs, num_pages, page_group_count, page_book_count = self.paginate(
+            group_qs, book_qs, group_count, book_count
         )
         if page_group_count:
             group_qs = self.annotate_card_aggregates(group_qs, self.model)
@@ -353,19 +199,18 @@ class BrowserView(BrowserBreadcrumbsView):
         # print(group_qs.explain())
         # print(group_qs.query)
 
-        recovered_group_list = self.re_cover_multi_groups(group_qs)
         total_count = page_group_count + page_book_count
-        return recovered_group_list, book_qs, num_pages, total_count, zero_pad
+        return group_qs, book_qs, num_pages, total_count, zero_pad, mtime
 
     def get_object(self):
         """Validate settings and get the querysets."""
-        group_list, book_qs, num_pages, total_count, zero_pad = (
+        group_qs, book_qs, num_pages, total_count, zero_pad, mtime = (
             self._get_group_and_books()
         )
 
         # get additional context
         parent_breadcrumbs = self.get_parent_breadcrumbs()
-        title = self._get_browser_page_title()
+        title = self.get_browser_page_title()
         # needs to happen after pagination
         # runs obj list query twice :/
         libraries_exist = Library.objects.filter(covers_only=False).exists()
@@ -376,141 +221,18 @@ class BrowserView(BrowserBreadcrumbsView):
                 "breadcrumbs": parent_breadcrumbs,
                 "title": title,
                 "model_group": self.model_group,
-                "groups": group_list,
+                "groups": group_qs,
                 "books": book_qs,
                 "zero_pad": zero_pad,
                 "num_pages": num_pages,
                 "total_count": total_count,
                 "admin_flags": self.admin_flags,
                 "libraries_exist": libraries_exist,
+                "mtime": mtime,
             }
         )
 
-    def _get_valid_browse_top_groups(self):
-        """Get valid top groups for the current settings.
-
-        Valid top groups are determined by the Browser Settings.
-        """
-        valid_top_groups = []
-
-        show = self.params["show"]
-        for nav_group, allowed in show.items():
-            if allowed:
-                valid_top_groups.append(nav_group)
-        # Issues is always a valid top group
-        valid_top_groups += [self.COMIC_GROUP]
-
-        return valid_top_groups
-
-    def _validate_top_group(self, valid_top_groups):
-        nav_group = self.kwargs.get("group")
-        top_group = self.params.get("top_group")
-        if top_group not in valid_top_groups:
-            reason = f"top_group {top_group} not in valid nav groups, changed to "
-            if nav_group in valid_top_groups:
-                valid_top_group = nav_group
-                reason += "nav group: "
-            else:
-                valid_top_group = valid_top_groups[0]
-                reason += "first valid top group "
-            reason += valid_top_group
-            pks = self.kwargs.get("pks", ())
-            page = self.kwargs["page"]
-            route = {"group": nav_group, "pks": pks, "page": page}
-            settings_mask = {"top_group": valid_top_group}
-            self._raise_redirect(reason, route, settings_mask)
-
-    def set_valid_browse_nav_groups(self, valid_top_groups):
-        """Get valid nav groups for the current settings.
-
-        Valid nav groups are the top group and below that are also
-        enabled in browser settings.
-
-        May always navigate to root 'r' nav group.
-        """
-        top_group = self.params["top_group"]
-        nav_group = self.kwargs["group"]
-        valid_nav_groups = [self.ROOT_GROUP]
-
-        for possible_index, possible_nav_group in enumerate(valid_top_groups):
-            if top_group == possible_nav_group:
-                # all the nav groups past this point,
-                # 'c' is obscured by the web reader url, but valid for opds
-                tail_top_groups = valid_top_groups[possible_index:]
-                valid_nav_groups += tail_top_groups
-
-                if nav_group not in valid_nav_groups:
-                    reason = (
-                        f"Nav group {nav_group} unavailable, "
-                        f"redirect to {self.ROOT_GROUP}"
-                    )
-                    self._raise_redirect(reason)
-                break
-        self.valid_nav_groups = tuple(valid_nav_groups)
-
-    def _validate_folder_settings(self):
-        """Check that all the view variables for folder mode are set right."""
-        # Check folder view admin flag
-        if not self.admin_flags["folder_view"]:
-            reason = "folder view disabled"
-            valid_top_groups = self._get_valid_browse_top_groups()
-            settings_mask = {"top_group": valid_top_groups[0]}
-            self._raise_redirect(reason, settings_mask=settings_mask)
-
-        valid_top_groups = (self.FOLDER_GROUP,)
-        self._validate_top_group(valid_top_groups)
-        self.valid_nav_groups = valid_top_groups
-
-    def _validate_browser_group_settings(self):
-        """Check that all the view variables for browser mode are set right."""
-        # Validate Browser top_group
-        # Change top_group if its not in the valid top groups
-        valid_top_groups = self._get_valid_browse_top_groups()
-        self._validate_top_group(valid_top_groups)
-
-        # Validate pks
-        nav_group = self.kwargs["group"]
-        pks = self.kwargs["pks"]
-        if nav_group == self.ROOT_GROUP and (pks and 0 not in pks):
-            # r never has pks
-            reason = f"Redirect r with {pks=} to pks 0"
-            self._raise_redirect(reason)
-
-        # Validate Browser nav_group
-        # Redirect if nav group is wrong
-        self.set_valid_browse_nav_groups(valid_top_groups)
-
-    def _validate_story_arc_settings(self):
-        """Validate story arc settings."""
-        valid_top_groups = (self.STORY_ARC_GROUP,)
-        self._validate_top_group(valid_top_groups)
-        self.valid_nav_groups = valid_top_groups
-
-    def validate_settings(self):
-        """Validate group and top group settings."""
-        group = self.kwargs["group"]
-        if group == self.FOLDER_GROUP:
-            self._validate_folder_settings()
-        elif group == self.STORY_ARC_GROUP:
-            self._validate_story_arc_settings()
-        else:
-            self._validate_browser_group_settings()
-
-        # Validate order
-        if self.order_key == "filename" and not self.admin_flags["folder_view"]:
-            pks = self.kwargs["pks"]
-            page = self.kwargs["page"]
-            route_changes = {"group": group, "pks": pks, "page": page}
-            reason = "order by filename not allowed by admin flag."
-            settings_mask = {"order_by": "sort_name"}
-            self._raise_redirect(reason, route_changes, settings_mask)
-
-    def init_request(self):
-        """Initialize request."""
-        super().init_request()
-        self._set_group_query_and_instance()
-
-    @extend_schema(request=BrowserBreadcrumbsView.input_serializer_class)
+    @extend_schema(request=BrowserTitleView.input_serializer_class)
     def get(self, *_args, **_kwargs):
         """Get browser settings."""
         self.init_request()

codex/views/browser/choices.py

@@ -1,7 +1,6 @@
 """View for marking comics read and unread."""
 
 from types import MappingProxyType
-from typing import ClassVar
 
 import pycountry
 from caseconverter import snakecase
@@ -13,12 +12,7 @@ from codex.logger.logging import get_logger
 from codex.models import (
     Comic,
     ContributorPerson,
-    Folder,
-    Imprint,
-    Publisher,
-    Series,
     StoryArc,
-    Volume,
 )
 from codex.models.named import IdentifierType
 from codex.serializers.browser.choices import CHOICES_SERIALIZER_CLASS_MAP
@@ -27,7 +21,6 @@ from codex.serializers.browser.filters import (
     CharListField,
 )
 from codex.serializers.models.pycountry import PyCountrySerializer
-from codex.views.auth import IsAuthenticatedOrEnabledNonUsers
 from codex.views.browser.filters.annotations import (
     BrowserAnnotationsFilterView,
 )
@@ -50,37 +43,21 @@ _FIELD_TO_REL_MODEL_MAP = MappingProxyType(
         ),
     }
 )
+_BACK_REL_MAP = MappingProxyType(
+    {
+        ContributorPerson: "contributor__",
+        StoryArc: "storyarcnumber__",
+        IdentifierType: "identifier__",
+    }
+)
+_NULL_NAMED_ROW = MappingProxyType({"pk": -1, "name": "_none_"})
 
 
 class BrowserChoicesViewBase(BrowserAnnotationsFilterView):
     """Get choices for filter dialog."""
 
-    permission_classes: ClassVar[list] = [IsAuthenticatedOrEnabledNonUsers]  # type: ignore
-
-    _CONTRIBUTORS_PERSON_REL = "contributors__person"
-    _STORY_ARC_REL = "story_arc_numbers__story_arc"
-    _IDENTIFIERS_REL = "identifiers__identifier_type"
-    _NULL_NAMED_ROW = MappingProxyType({"pk": -1, "name": "_none_"})
-    _BACK_REL_MAP = MappingProxyType(
-        {
-            ContributorPerson: "contributor__",
-            StoryArc: "storyarcnumber__",
-            IdentifierType: "identifier__",
-        }
-    )
-    _REL_MAP = MappingProxyType(
-        {
-            Publisher: "publisher",
-            Imprint: "imprint",
-            Series: "series",
-            Volume: "volume",
-            Comic: "pk",
-            Folder: "parent_folder",
-            StoryArc: "story_arc_numbers__story_arc",
-            IdentifierType: "identifiers__identifier_type",
-        }
-    )
-    _SERIALIZER_MANY = False
+    SERIALIZER_MANY = False
+    TARGET = "choices"
 
     @staticmethod
     def get_field_choices_query(comic_qs, field_name):
@@ -93,21 +70,13 @@ class BrowserChoicesViewBase(BrowserAnnotationsFilterView):
 
     def get_m2m_field_query(self, model, comic_qs: QuerySet):
         """Get distinct m2m value objects for the relation."""
-        if self.model is None:
-            LOG.error("No model to make filter choices!")
-            m2m_filter = {}
-        else:
-            model_rel: str = self._REL_MAP[self.model]  # type: ignore
-            back_rel = self._BACK_REL_MAP.get(model, "")
-            back_rel += "comic__"
-            back_rel += model_rel
-            back_rel += "__in"
-            m2m_filter = {back_rel: comic_qs}
+        back_rel = _BACK_REL_MAP.get(model, "")
+        m2m_filter = {f"{back_rel}comic__in": comic_qs}
         return model.objects.filter(**m2m_filter).values("pk", "name").distinct()
 
     @staticmethod
     def does_m2m_null_exist(comic_qs, rel):
-        """Get if null values exists for an m2m field."""
+        """Get if comics exist in the filter without values exists for an m2m field."""
         return comic_qs.filter(**{f"{rel}__isnull": True}).exists()
 
     def get_rel_and_model(self, field_name):
@@ -122,22 +91,18 @@ class BrowserChoicesViewBase(BrowserAnnotationsFilterView):
             rel = field_name
             model = remote_field.model if remote_field else None
 
-        rel = self.rel_prefix + rel
-
         return rel, model
 
     def get_object(self):
         """Get the comic subquery use for the choices."""
-        object_filter = self.get_query_filters(self.model, choices=True)
-        qs = self.model.objects.filter(object_filter)  # type: ignore
-        return self.filter_by_annotations(qs, self.model, binary=True)
+        return self.get_filtered_queryset(Comic)
 
     @extend_schema(request=BrowserAnnotationsFilterView.input_serializer_class)
     def get(self, *_args, **_kwargs):
         """Return choices."""
         self.init_request()
         obj = self.get_object()
-        serializer = self.get_serializer(obj, many=self._SERIALIZER_MANY)
+        serializer = self.get_serializer(obj, many=self.SERIALIZER_MANY)
         return Response(serializer.data)
 
 
@@ -170,6 +135,7 @@ class BrowserChoicesAvailableView(BrowserChoicesViewBase):
     def get_object(self):
         """Get choice counts."""
         qs = super().get_object()
+        filters = self.params.get("filters", {})
         data = {}
         for field_name in self.serializer_class().get_fields():  # type: ignore
             if field_name == "story_arcs" and self.model == StoryArc:
@@ -182,9 +148,9 @@ class BrowserChoicesAvailableView(BrowserChoicesViewBase):
             else:
                 count = self._get_field_choices_count(qs, rel)
 
-            filters = self.params.get("filters", {})
             try:
-                flag = count > 1 or field_name in filters  # type: ignore
+                is_filter_set = bool(filters.get(field_name))
+                flag = is_filter_set or count > 1  # type: ignore
             except TypeError:
                 flag = False
             data[field_name] = flag
@@ -195,7 +161,9 @@ class BrowserChoicesView(BrowserChoicesViewBase):
     """Get choices for filter dialog."""
 
     # serializer_class = Dynamic class determined in get()
-    _SERIALIZER_MANY = True
+    SERIALIZER_MANY = True
+    # HACK get_serializer(data, many=True) requires this to be set for the debug API view
+    queryset = Comic.objects.none()
 
     def _get_field_choices(self, comic_qs, field_name):
         """Create a pk:name object for fields without tables."""
@@ -225,7 +193,7 @@ class BrowserChoicesView(BrowserChoicesViewBase):
         # rows. :(
         if self.does_m2m_null_exist(comic_qs, rel):
             choices = list(qs)
-            choices.append(self._NULL_NAMED_ROW)
+            choices.append(_NULL_NAMED_ROW)
         else:
             choices = qs
         return choices