codex 1.4.1__py3-none-any.whl → 1.4.3__py3-none-any.whl

codex/views/bookmark.py

@@ -1,4 +1,6 @@
 """Bookmark views."""
+from typing import ClassVar
+
 from drf_spectacular.utils import extend_schema
 from rest_framework.generics import GenericAPIView
 from rest_framework.response import Response
@@ -15,16 +17,16 @@ LOG = get_logger(__name__)
 class BookmarkBaseView(GenericAPIView, GroupACLMixin):
     """Bookmark Updater."""
 
-    permission_classes = [IsAuthenticatedOrEnabledNonUsers]
-    _BOOKMARK_UPDATE_FIELDS = [
+    permission_classes: ClassVar[list] = [IsAuthenticatedOrEnabledNonUsers]
+    _BOOKMARK_UPDATE_FIELDS = (
         "page",
         "finished",
         "fit_to",
         "two_pages",
         "vertical",
         "read_in_reverse",
-    ]
-    _BOOKMARK_ONLY_FIELDS = [*_BOOKMARK_UPDATE_FIELDS, "pk", "comic"]
+    )
+    _BOOKMARK_ONLY_FIELDS = (*_BOOKMARK_UPDATE_FIELDS, "pk", "comic")
     _COMIC_ONLY_FIELDS = ("pk", "max_page")
 
     def get_bookmark_filter(self):

codex/views/browser/base.py

@@ -1,6 +1,7 @@
 """Views for browsing comic library."""
 import json
 from copy import deepcopy
+from types import MappingProxyType
 from urllib.parse import unquote_plus
 
 from django.contrib.auth.models import User
@@ -8,7 +9,15 @@ from djangorestframework_camel_case.settings import api_settings
 from djangorestframework_camel_case.util import underscoreize
 
 from codex.logger.logging import get_logger
-from codex.models import Comic, Folder, Imprint, Publisher, Series, StoryArc, Volume
+from codex.models import (
+    Comic,
+    Folder,
+    Imprint,
+    Publisher,
+    Series,
+    StoryArc,
+    Volume,
+)
 from codex.serializers.browser import BrowserSettingsSerializer
 from codex.views.browser.filters.bookmark import BookmarkFilterMixin
 from codex.views.browser.filters.field import ComicFieldFilter
@@ -25,16 +34,18 @@ class BrowserBaseView(
 
     input_serializer_class = BrowserSettingsSerializer
 
-    GROUP_MODEL_MAP = {
-        GroupFilterMixin.ROOT_GROUP: None,
-        "p": Publisher,
-        "i": Imprint,
-        "s": Series,
-        "v": Volume,
-        GroupFilterMixin.COMIC_GROUP: Comic,
-        GroupFilterMixin.FOLDER_GROUP: Folder,
-        GroupFilterMixin.STORY_ARC_GROUP: StoryArc,
-    }
+    GROUP_MODEL_MAP = MappingProxyType(
+        {
+            GroupFilterMixin.ROOT_GROUP: None,
+            "p": Publisher,
+            "i": Imprint,
+            "s": Series,
+            "v": Volume,
+            GroupFilterMixin.COMIC_GROUP: Comic,
+            GroupFilterMixin.FOLDER_GROUP: Folder,
+            GroupFilterMixin.STORY_ARC_GROUP: StoryArc,
+        }
+    )
 
     _GET_JSON_KEYS = frozenset(("filters", "show"))
 
@@ -51,26 +62,19 @@ class BrowserBaseView(
             self._is_admin = user and isinstance(user, User) and user.is_staff
         return self._is_admin
 
-    def get_query_filters_without_group(self, model):
+    def get_query_filters_without_group(self, model, search_scores: dict):
         """Return all the filters except the group filter."""
         object_filter = self.get_group_acl_filter(model)
-
-        search_filter, search_scores = self.get_search_filter()
-        object_filter &= search_filter
+        object_filter &= self.get_search_filter(model, search_scores)
         object_filter &= self.get_bookmark_filter(model)
         object_filter &= self.get_comic_field_filter()
-        return object_filter, search_scores
+        return object_filter
 
-    def get_query_filters(self, model, choices=False):
+    def get_query_filters(self, model, search_scores: dict, choices=False):
         """Return the main object filter and the one for aggregates."""
-        (
-            object_filter,
-            search_scores,
-        ) = self.get_query_filters_without_group(model)
-
+        object_filter = self.get_query_filters_without_group(model, search_scores)
         object_filter &= self.get_group_filter(choices)
-
-        return object_filter, search_scores
+        return object_filter
 
     def _parse_query_params(self, query_params):
         """Parse GET query parameters: filter object & snake case."""
@@ -85,13 +89,11 @@ class BrowserBaseView(
                 parsed_val = val
 
             result[key] = parsed_val
-        result = underscoreize(result, **api_settings.JSON_UNDERSCOREIZE)
-
-        return result
+        return underscoreize(result, **api_settings.JSON_UNDERSCOREIZE)
 
     def parse_params(self):
         """Validate sbmitted settings and apply them over the session settings."""
-        self.params = deepcopy(self.SESSION_DEFAULTS)
+        self.params = deepcopy(dict(self.SESSION_DEFAULTS))
         if self.request.method == "GET":
             data = self._parse_query_params(self.request.GET)
         elif hasattr(self.request, "data"):

codex/views/browser/browser.py

@@ -1,9 +1,10 @@
 """Views for browsing comic library."""
 from copy import deepcopy
-from typing import Optional, Union
+from types import MappingProxyType
+from typing import ClassVar, Optional
 
 from django.core.paginator import EmptyPage, Paginator
-from django.db.models import F, Max, Q, Value
+from django.db.models import F, Max, Value
 from django.db.models.fields import (
     CharField,
 )
@@ -14,6 +15,7 @@ from codex.exceptions import SeeOtherRedirectError
 from codex.logger.logging import get_logger
 from codex.models import (
     AdminFlag,
+    BrowserGroupModel,
     Comic,
     Folder,
     Imprint,
@@ -35,28 +37,34 @@ LOG = get_logger(__name__)
 class BrowserView(BrowserAnnotationsView):
     """Browse comics with a variety of filters and sorts."""
 
-    permission_classes = [IsAuthenticatedOrEnabledNonUsers]
+    permission_classes: ClassVar[list] = [IsAuthenticatedOrEnabledNonUsers]
     serializer_class = BrowserPageSerializer
 
     MAX_OBJ_PER_PAGE = 100
-    _MODEL_GROUP_MAP = {v: k for k, v in BrowserAnnotationsView.GROUP_MODEL_MAP.items()}
+    _MODEL_GROUP_MAP = MappingProxyType(
+        {v: k for k, v in BrowserAnnotationsView.GROUP_MODEL_MAP.items()}
+    )
     _NAV_GROUPS = "rpisv"
     _ORPHANS = int(MAX_OBJ_PER_PAGE / 20)
 
-    _GROUP_INSTANCE_SELECT_RELATED = {
-        Comic: ("series", "volume"),
-        Volume: ("series",),
-        Series: (None,),
-        Imprint: ("publisher",),
-        Publisher: (None,),
-        Folder: ("parent_folder",),
-        StoryArc: (None,),
-    }
+    _GROUP_INSTANCE_SELECT_RELATED = MappingProxyType(
+        {
+            Comic: ("series", "volume"),
+            Volume: ("series",),
+            Series: (None,),
+            Imprint: ("publisher",),
+            Publisher: (None,),
+            Folder: ("parent_folder",),
+            StoryArc: (None,),
+        }
+    )
     DEFAULT_ROUTE_NAME = "browser"
-    _DEFAULT_ROUTE = {
-        "name": DEFAULT_ROUTE_NAME,
-        "params": deepcopy(DEFAULTS["route"]),
-    }
+    _DEFAULT_ROUTE = MappingProxyType(
+        {
+            "name": DEFAULT_ROUTE_NAME,
+            "params": deepcopy(DEFAULTS["route"]),
+        }
+    )
     _OPDS_M2M_RELS = (
         "characters",
         "genres",
@@ -91,7 +99,7 @@ class BrowserView(BrowserAnnotationsView):
             group_names["publisher_name"] = F("publisher__name")
         return queryset.annotate(**group_names)
 
-    def _add_annotations(self, queryset, model, search_scores):
+    def _add_annotations(self, queryset, model, search_scores: dict):
         """Annotations for display and sorting."""
         queryset = self.annotate_common_aggregates(queryset, model, search_scores)
 
@@ -127,30 +135,26 @@ class BrowserView(BrowserAnnotationsView):
         model_group = self._get_model_group()
         self.model = self.GROUP_MODEL_MAP[model_group]
 
-    def _get_group_queryset(self, object_filter, search_scores):
+    def _get_group_queryset(self, search_scores: dict):
         """Create group queryset."""
-        if self.model == Comic:
-            qs = self.model.objects.none()
-        else:
+        if not self.model:
+            reason = "Model not set in browser."
+            raise ValueError(reason)
+        if self.model != Comic:
+            object_filter = self.get_query_filters(self.model, search_scores, False)
             qs = self.model.objects.filter(object_filter)
             qs = self._add_annotations(qs, self.model, search_scores)
             qs = self.add_order_by(qs, self.model)
+        else:
+            qs = self.model.objects.none()
         return qs
 
-    def _get_book_queryset(self, object_filter, search_scores):
+    def _get_book_queryset(self, search_scores: dict):
         """Create book queryset."""
-        group = self.kwargs.get("group")
-        if self.model == Comic or group == self.FOLDER_GROUP:
-            if group == self.FOLDER_GROUP:
-                comic_object_filter, comic_search_scores = self.get_query_filters(
-                    self.model, False
-                )
-            else:
-                comic_object_filter = object_filter
-                comic_search_scores = search_scores
-
-            qs = Comic.objects.filter(comic_object_filter)
-            qs = self._add_annotations(qs, Comic, comic_search_scores)
+        if self.model in (Comic, Folder):
+            object_filter = self.get_query_filters(Comic, search_scores, False)
+            qs = Comic.objects.filter(object_filter)
+            qs = self._add_annotations(qs, Comic, search_scores)
             qs = self.add_order_by(qs, Comic)
             if limit := self.params.get("limit"):
                 qs = qs[:limit]
@@ -182,20 +186,20 @@ class BrowserView(BrowserAnnotationsView):
     def _set_group_instance(self):
         """Create group_class instance."""
         pk = self.kwargs.get("pk")
-        self.group_instance: Optional[
-            Union[Folder, Publisher, Imprint, Series, Volume, StoryArc]
-        ] = None
-        if not pk:
-            return
-        try:
-            select_related = self._GROUP_INSTANCE_SELECT_RELATED[self.group_class]
-            self.group_instance = self.group_class.objects.select_related(
-                *select_related
-            ).get(pk=pk)
-        except self.group_class.DoesNotExist:
-            group = self.kwargs.get("group")
-            reason = f"{group}={pk} does not exist!"
-            self._raise_redirect({"group": group, "pk": 0, "page": 1}, reason)
+        if pk and self.group_class:
+            try:
+                select_related: tuple[str, ...] = self._GROUP_INSTANCE_SELECT_RELATED[
+                    self.group_class
+                ]  # type: ignore
+                self.group_instance: Optional[
+                    BrowserGroupModel
+                ] = self.group_class.objects.select_related(*select_related).get(pk=pk)
+            except self.group_class.DoesNotExist:
+                group = self.kwargs.get("group")
+                reason = f"{group}={pk} does not exist!"
+                self._raise_redirect({"group": group, "pk": 0, "page": 1}, reason)
+        else:
+            self.group_instance: Optional[BrowserGroupModel] = None
 
     def _get_browse_up_route(self):
         """Get the up route from the first valid ancestor."""
@@ -247,8 +251,7 @@ class BrowserView(BrowserAnnotationsView):
             # remove library path for not admins
             parent_name = parent_name.removeprefix(prefix)
         suffix = "/" + group_instance.name
-        parent_name = parent_name.removesuffix(suffix)
-        return parent_name
+        return parent_name.removesuffix(suffix)
 
     def _get_browser_page_title(self):
         """Get the proper title for this browse level."""
@@ -298,7 +301,8 @@ class BrowserView(BrowserAnnotationsView):
         except EmptyPage:
             if page < 1 or page > paginator.num_pages:
                 self._page_out_out_bounds(page, paginator.num_pages)
-            LOG.warning(f"No {self.model.__class__.__name__}s on page {page}")
+            model_name = self.model.__name__ if self.model else "NO_MODEL"
+            LOG.warning(f"No {model_name}s on page {page}")
             model.objects.none()
 
         return qs, num_pages, total_count
@@ -329,20 +333,11 @@ class BrowserView(BrowserAnnotationsView):
         self.set_rel_prefix(self.model)
         self._set_group_instance()  # Placed up here to invalidate earlier
         # Create the main query with the filters
-        try:
-            object_filter, search_scores = self.get_query_filters(self.model, False)
-        except Folder.DoesNotExist:
-            pk = self.kwargs.get("pk")
-            self._raise_redirect(
-                {"group": self.FOLDER_GROUP},
-                f"folder {pk} Does not exist! Redirect to root folder.",
-            )
-            object_filter = Q()
-            search_scores = {}
+        search_scores: dict = self.get_search_scores()
         group = self.kwargs.get("group")
 
-        group_qs = self._get_group_queryset(object_filter, search_scores)
-        book_qs = self._get_book_queryset(object_filter, search_scores)
+        group_qs = self._get_group_queryset(search_scores)
+        book_qs = self._get_book_queryset(search_scores)
 
         # Paginate
         group_qs, book_qs, num_pages, total_count = self._paginate(group_qs, book_qs)
@@ -377,19 +372,21 @@ class BrowserView(BrowserAnnotationsView):
         )
 
         # construct final data structure
-        return {
-            "up_route": up_route,
-            "browser_title": browser_page_title,
-            "model_group": self.model_group,
-            "groups": group_qs,
-            "books": book_qs,
-            "issue_max": issue_max,
-            "num_pages": num_pages,
-            "total_count": total_count,
-            "admin_flags": {"folder_view": efv_flag.on},
-            "libraries_exist": libraries_exist,
-            "covers_timestamp": covers_timestamp,
-        }
+        return MappingProxyType(
+            {
+                "up_route": up_route,
+                "browser_title": browser_page_title,
+                "model_group": self.model_group,
+                "groups": group_qs,
+                "books": book_qs,
+                "issue_max": issue_max,
+                "num_pages": num_pages,
+                "total_count": total_count,
+                "admin_flags": {"folder_view": efv_flag.on},
+                "libraries_exist": libraries_exist,
+                "covers_timestamp": covers_timestamp,
+            }
+        )
 
     def _get_valid_top_groups(self):
         """Get valid top groups for the current settings.
@@ -398,8 +395,9 @@ class BrowserView(BrowserAnnotationsView):
         """
         valid_top_groups = []
 
+        show: MappingProxyType = self.params["show"]  # type:ignore
         for nav_group in self._NAV_GROUPS:
-            if self.params["show"].get(nav_group):
+            if show.get(nav_group):
                 valid_top_groups.append(nav_group)
         # Issues is always a valid top group
         valid_top_groups += [self.COMIC_GROUP]
@@ -436,8 +434,8 @@ class BrowserView(BrowserAnnotationsView):
 
     def _raise_redirect(self, route_mask, reason, settings_mask=None):
         """Redirect the client to a valid group url."""
-        route = deepcopy(self._DEFAULT_ROUTE)
-        route["params"].update(route_mask)
+        route = deepcopy(dict(self._DEFAULT_ROUTE))
+        route["params"].update(route_mask)  # type: ignore
         settings = deepcopy(self.params)
         if settings_mask:
             settings.update(settings_mask)

codex/views/browser/browser_annotations.py

@@ -9,6 +9,7 @@ from django.db.models import (
     DateTimeField,
     F,
     FilteredRelation,
+    Max,
     Min,
     OuterRef,
     Q,
@@ -49,15 +50,19 @@ class BrowserAnnotationsView(BrowserOrderByView):
 
     is_opds_1_acquisition = False
 
-    def _annotate_search_score(self, queryset, search_scores):
-        """Annotate the search score for ordering by search score."""
+    def _annotate_search_score(self, queryset, search_scores, model):
+        """Annotate the search score for ordering by search score.
+
+        Choose the maximum matching score for the group.
+        """
         if self.order_key != "search_score":
             return queryset
         whens = []
+        prefix = "" if model == Comic else self.rel_prefix
         for pk, score in search_scores.items():
-            when = {self.rel_prefix + "pk": pk, "then": score}
+            when = {prefix + "pk": pk, "then": score}
             whens.append(When(**when))
-        annotate = {self.rel_prefix + "search_score": Case(*whens, default=0.0)}
+        annotate = {"search_score": Max(Case(*whens, default=0.0))}
         return queryset.annotate(**annotate)
 
     def _annotate_cover_pk(self, queryset, model):
@@ -116,14 +121,13 @@ class BrowserAnnotationsView(BrowserOrderByView):
 
         if self.kwargs.get("group") == self.FOLDER_GROUP and model == Comic:
             # File View Filename
-            queryset = queryset.annotate(
+            return queryset.annotate(
                 sort_name=Right(
                     "path",
                     StrIndex(Reverse(F("path")), Value(sep)) - 1,  # type: ignore
                     output_field=CharField(),
                 )
             )
-            return queryset
 
         ##################################################
         # Otherwise Remove articles from the browse name #
@@ -168,7 +172,9 @@ class BrowserAnnotationsView(BrowserOrderByView):
         pk = self.kwargs["pk"]
         if group == self.STORY_ARC_GROUP and pk:
             story_arc_pk = pk
-        elif story_arc_pks := self.params.get("filters", {}).get("story_arcs", []):
+        elif story_arc_pks := self.params.get("filters", {}).get(  # type: ignore
+            "story_arcs", []
+        ):
             story_arc_pk = story_arc_pks[0]
         else:
             story_arc_pk = None
@@ -261,7 +267,7 @@ class BrowserAnnotationsView(BrowserOrderByView):
 
     def annotate_common_aggregates(self, qs, model, search_scores):
         """Annotate common aggregates between browser and metadata."""
-        qs = self._annotate_search_score(qs, search_scores)
+        qs = self._annotate_search_score(qs, search_scores, model)
         qs = self._annotate_child_count(qs, model)
         qs = self._annotate_page_count(qs, model)
         bm_rel = self.get_bm_rel(model)
@@ -273,5 +279,4 @@ class BrowserAnnotationsView(BrowserOrderByView):
         # cover depends on the above annotations for order-by
         qs = self._annotate_cover_pk(qs, model)
         qs = self._annotate_bookmarks(qs, model, bm_rel, bm_filter)
-        qs = self._annotate_progress(qs)
-        return qs
+        return self._annotate_progress(qs)

codex/views/browser/browser_order_by.py

@@ -1,5 +1,6 @@
 """Base view for ordering the query."""
 from os import sep
+from types import MappingProxyType
 
 from django.db.models import Avg, F, Max, Min, Sum, Value
 from django.db.models.functions import Reverse, Right, StrIndex
@@ -11,21 +12,25 @@ from codex.views.browser.base import BrowserBaseView
 class BrowserOrderByView(BrowserBaseView):
     """Base class for views that need ordering."""
 
-    _ORDER_AGGREGATE_FUNCS = {
-        "age_rating": Avg,
-        "community_rating": Avg,
-        "created_at": Min,
-        "critical_rating": Avg,
-        "date": Min,
-        "page_count": Sum,
-        "path": Min,
-        "size": Sum,
-        "updated_at": Min,
-        "search_score": Min,
-        "story_arc_number": Min,
-    }
+    _ORDER_AGGREGATE_FUNCS = MappingProxyType(
+        {
+            "age_rating": Avg,
+            "community_rating": Avg,
+            "created_at": Min,
+            "critical_rating": Avg,
+            "date": Min,
+            "page_count": Sum,
+            "path": Min,
+            "size": Sum,
+            "updated_at": Min,
+            "search_score": Min,
+            "story_arc_number": Min,
+        }
+    )
     _SEP_VALUE = Value(sep)
-    _ANNOTATED_ORDER_FIELDS = frozenset(("sort_name", "bookmark_updated_at"))
+    _ANNOTATED_ORDER_FIELDS = frozenset(
+        ("sort_name", "search_score", "bookmark_updated_at")
+    )
 
     def set_order_key(self):
         """Get the default order key for the view."""
@@ -70,7 +75,7 @@ class BrowserOrderByView(BrowserBaseView):
             func = self._get_path_query_func(self.order_key)
         elif model == Comic or self.order_key in self._ANNOTATED_ORDER_FIELDS:
             # agg_none uses group fields not comic fields.
-            func = F(self.order_key)
+            func = F(self.order_key)  # type: ignore
         else:
             func = self.get_aggregate_func(model, self.order_key)
         return func
@@ -82,7 +87,7 @@ class BrowserOrderByView(BrowserBaseView):
             prefix += "-"
 
         if self.order_key == "sort_name":
-            order_fields = ("order_value", *model.ORDERING[1:])
+            order_fields = model.ORDERING
         elif self.order_key == "bookmark_updated_at":
             order_fields = ("order_value", "updated_at", "created_at", "pk")
         elif self.order_key == "story_arc_number" and model == Comic:

codex/views/browser/choices.py

@@ -1,4 +1,7 @@
 """View for marking comics read and unread."""
+from types import MappingProxyType
+from typing import ClassVar, Union
+
 import pycountry
 from caseconverter import snakecase
 from django.db.models import QuerySet
@@ -7,6 +10,7 @@ from rest_framework.response import Response
 
 from codex.logger.logging import get_logger
 from codex.models import (
+    BrowserGroupModel,
     Comic,
     CreatorPerson,
     Folder,
@@ -30,21 +34,25 @@ LOG = get_logger(__name__)
 class BrowserChoicesViewBase(BrowserBaseView):
     """Get choices for filter dialog."""
 
-    permission_classes = [IsAuthenticatedOrEnabledNonUsers]
+    permission_classes: ClassVar[list] = [IsAuthenticatedOrEnabledNonUsers]
 
     _CREATORS_PERSON_REL = "creators__person"
     _STORY_ARC_REL = "story_arc_numbers__story_arc"
-    _NULL_NAMED_ROW = {"pk": -1, "name": "_none_"}
-    _BACK_REL_MAP = {CreatorPerson: "creator__", StoryArc: "storyarcnumber__"}
-    _REL_MAP = {
-        Publisher: "publisher",
-        Imprint: "imprint",
-        Series: "series",
-        Volume: "volume",
-        Comic: "pk",
-        Folder: "parent_folder",
-        StoryArc: "story_arc_numbers__story_arc",
-    }
+    _NULL_NAMED_ROW = MappingProxyType({"pk": -1, "name": "_none_"})
+    _BACK_REL_MAP = MappingProxyType(
+        {CreatorPerson: "creator__", StoryArc: "storyarcnumber__"}
+    )
+    _REL_MAP = MappingProxyType(
+        {
+            Publisher: "publisher",
+            Imprint: "imprint",
+            Series: "series",
+            Volume: "volume",
+            Comic: "pk",
+            Folder: "parent_folder",
+            StoryArc: "story_arc_numbers__story_arc",
+        }
+    )
 
     @staticmethod
     def get_field_choices_query(comic_qs, field_name):
@@ -57,13 +65,17 @@ class BrowserChoicesViewBase(BrowserBaseView):
 
     def get_m2m_field_query(self, model, comic_qs: QuerySet):
         """Get distinct m2m value objects for the relation."""
-        back_rel = self._BACK_REL_MAP.get(model, "")
-        back_rel += "comic__"
-        back_rel += self._REL_MAP[self.model]
-        back_rel += "__in"
-        return (
-            model.objects.filter(**{back_rel: comic_qs}).values("pk", "name").distinct()
-        )
+        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}
+        return model.objects.filter(**m2m_filter).values("pk", "name").distinct()
 
     @staticmethod
     def does_m2m_null_exist(comic_qs, rel):
@@ -91,15 +103,18 @@ class BrowserChoicesViewBase(BrowserBaseView):
 
     def get_object(self):
         """Get the comic subquery use for the choices."""
-        object_filter, _ = self.get_query_filters(self.model, True)
-        return self.model.objects.filter(object_filter)
+        search_scores = self.get_search_scores()
+        object_filter = self.get_query_filters(self.model, search_scores, True)
+        return self.model.objects.filter(object_filter)  # type: ignore
 
     def _set_model(self):
         """Set the model to query."""
         group = self.kwargs["group"]
         if group == self.ROOT_GROUP:
             group = self.params.get("top_group", "p")
-        self.model = self.GROUP_MODEL_MAP[group]
+        self.model: Union[BrowserGroupModel, Comic, None] = self.GROUP_MODEL_MAP[
+            group
+        ]  # type: ignore
 
 
 class BrowserChoicesAvailableView(BrowserChoicesViewBase):