codex 1.7.14__py3-none-any.whl → 1.8.0__py3-none-any.whl

codex/views/opds/v1/feed.py

@@ -1,21 +1,24 @@
 """OPDS v1 feed."""
 
+from collections.abc import Sequence
 from typing import TYPE_CHECKING, Any
 
 from drf_spectacular.utils import extend_schema
+from loguru import logger
 from rest_framework.response import Response
-from rest_framework.throttling import ScopedRateThrottle
+from rest_framework.serializers import BaseSerializer
+from rest_framework.throttling import BaseThrottle, ScopedRateThrottle
+from typing_extensions import override
 
-from codex.librarian.importer.tasks import LazyImportComicsTask
 from codex.librarian.mp_queue import LIBRARIAN_QUEUE
-from codex.logger.logger import get_logger
+from codex.librarian.scribe.tasks import LazyImportComicsTask
 from codex.serializers.browser.settings import OPDSSettingsSerializer
 from codex.serializers.opds.v1 import (
     OPDS1TemplateSerializer,
 )
-from codex.settings.settings import FALSY, MAX_OBJ_PER_PAGE
-from codex.views.mixins import UserActiveViewMixin
-from codex.views.opds.auth import OPDSTemplateView
+from codex.settings import FALSY, MAX_OBJ_PER_PAGE
+from codex.views.mixins import UserActiveMixin
+from codex.views.opds.auth import OPDSTemplateMixin
 from codex.views.opds.const import BLANK_TITLE
 from codex.views.opds.v1.entry.data import OPDS1EntryData
 from codex.views.opds.v1.entry.entry import OPDS1Entry
@@ -29,9 +32,6 @@ if TYPE_CHECKING:
     from collections.abc import Mapping
 
 
-LOG = get_logger(__name__)
-
-
 class OpdsNs:
     """XML Namespaces."""
 
@@ -39,15 +39,15 @@ class OpdsNs:
     ACQUISITION = "http://opds-spec.org/2010/acquisition"
 
 
-class OPDS1FeedView(OPDS1LinksView, OPDSTemplateView, UserActiveViewMixin):
+class OPDS1FeedView(OPDSTemplateMixin, UserActiveMixin, OPDS1LinksView):
     """OPDS 1 Feed."""
 
     template_name = "opds_v1/index.xml"
-    serializer_class = OPDS1TemplateSerializer
-    input_serializer_class = OPDSSettingsSerializer
-    throttle_classes = (ScopedRateThrottle,)
+    serializer_class: type[BaseSerializer] | None = OPDS1TemplateSerializer
+    input_serializer_class: type[OPDSSettingsSerializer] = OPDSSettingsSerializer  # pyright: ignore[reportIncompatibleVariableOverride]
+    throttle_classes: Sequence[type[BaseThrottle]] = (ScopedRateThrottle,)
     throttle_scope = "opds"
-    TARGET = "opds1"
+    TARGET: str = "opds1"
 
     @property
     def opds_ns(self):
@@ -55,7 +55,7 @@ class OPDS1FeedView(OPDS1LinksView, OPDSTemplateView, UserActiveViewMixin):
         try:
             return OpdsNs.ACQUISITION if self.is_opds_acquisition else OpdsNs.CATALOG
         except Exception:
-            LOG.exception("Getting OPDS v1 namespace")
+            logger.exception("Getting OPDS v1 namespace")
 
     @property
     def is_acquisition(self):
@@ -68,7 +68,7 @@ class OPDS1FeedView(OPDS1LinksView, OPDSTemplateView, UserActiveViewMixin):
         try:
             return self.request.build_absolute_uri()
         except Exception:
-            LOG.exception("Getting OPDS v1 ID Tag")
+            logger.exception("Getting OPDS v1 ID Tag")
 
     @property
     def title(self):
@@ -87,7 +87,7 @@ class OPDS1FeedView(OPDS1LinksView, OPDSTemplateView, UserActiveViewMixin):
             if not result:
                 result = BLANK_TITLE
         except Exception:
-            LOG.exception("Getting OPDS v1 feed title")
+            logger.exception("Getting OPDS v1 feed title")
         return result
 
     @property
@@ -99,7 +99,7 @@ class OPDS1FeedView(OPDS1LinksView, OPDSTemplateView, UserActiveViewMixin):
             if mtime:
                 datestr = mtime.isoformat()
         except Exception:
-            LOG.exception("Getting OPDS v1 updated")
+            logger.exception("Getting OPDS v1 updated")
         return datestr
 
     @property
@@ -109,7 +109,7 @@ class OPDS1FeedView(OPDS1LinksView, OPDSTemplateView, UserActiveViewMixin):
             if self.params.get("q"):
                 return MAX_OBJ_PER_PAGE
         except Exception:
-            LOG.exception("Getting OPDS v1 items per page")
+            logger.exception("Getting OPDS v1 items per page")
 
     @property
     def total_results(self):
@@ -118,7 +118,7 @@ class OPDS1FeedView(OPDS1LinksView, OPDSTemplateView, UserActiveViewMixin):
             if self.params.get("q"):
                 return self.obj.get("total_count", 0)
         except Exception:
-            LOG.exception("Getting OPDS v1 total results")
+            logger.exception("Getting OPDS v1 total results")
 
     def _get_entries_section(self, key, metadata):
         """Get entries by key section."""
@@ -141,7 +141,7 @@ class OPDS1FeedView(OPDS1LinksView, OPDSTemplateView, UserActiveViewMixin):
                     import_pks.add(obj.pk)
                 entries.append(entry)
             if import_pks:
-                task = LazyImportComicsTask(frozenset(import_pks))
+                task = LazyImportComicsTask(group="c", pks=frozenset(import_pks))
                 LIBRARIAN_QUEUE.put(task)
         return entries
 
@@ -161,9 +161,10 @@ class OPDS1FeedView(OPDS1LinksView, OPDSTemplateView, UserActiveViewMixin):
             metadata = self.request.GET.get("opdsMetadata", "").lower() not in FALSY
             entries += self._get_entries_section("books", metadata)
         except Exception:
-            LOG.exception("Getting OPDS v1 entries")
+            logger.exception("Getting OPDS v1 entries")
         return entries
 
+    @override
     @extend_schema(parameters=[input_serializer_class])
     def get(self, *_args, **_kwargs):
         """Get the feed."""

codex/views/opds/v1/links.py

@@ -7,18 +7,15 @@ from types import MappingProxyType
 
 import simplejson as json
 from django.urls import reverse
+from loguru import logger
 
-from codex.logger.logger import get_logger
 from codex.views.opds.const import MimeType, Rel
-from codex.views.opds.util import update_href_query_params
 from codex.views.opds.v1.data import OPDS1Link
 from codex.views.opds.v1.entry.data import OPDS1EntryData, OPDS1EntryObject
 from codex.views.opds.v1.entry.entry import OPDS1Entry
 from codex.views.opds.v1.facets import OPDS1FacetsView
 from codex.views.util import pop_name
 
-LOG = get_logger(__name__)
-
 
 class TopRoutes:
     """Routes for top groups."""
@@ -130,8 +127,7 @@ class OPDS1LinksView(OPDS1FacetsView):
         if query_params is None:
             query_params = self.request.GET
         kwargs = pop_name(kwargs)
-        href = reverse("opds:v1:feed", kwargs=kwargs)
-        href = update_href_query_params(href, query_params)
+        href = reverse("opds:v1:feed", kwargs=kwargs, query=query_params)
         return OPDS1Link(rel, href, mime_type)
 
     def _top_link(self, top_link):
@@ -182,7 +178,7 @@ class OPDS1LinksView(OPDS1FacetsView):
                 if facets := self.facets(entries=False, root=True):
                     links += facets
         except Exception:
-            LOG.exception("Getting OPDS v1 links")
+            logger.exception("Getting OPDS v1 links")
         return links
 
     def _top_link_entry(self, top_link):

codex/views/opds/v1/opensearch_v1.py

@@ -1,17 +1,20 @@
 """Serve an opensearch v1 document."""
 
+from collections.abc import Sequence
+
 from drf_spectacular.types import OpenApiTypes
 from drf_spectacular.utils import extend_schema
-from rest_framework.throttling import ScopedRateThrottle
+from rest_framework.throttling import BaseThrottle, ScopedRateThrottle
 
-from codex.views.opds.auth import OPDSTemplateView
+from codex.views.opds.auth import OPDSTemplateMixin
+from codex.views.template import CodexAPIView
 
 
 @extend_schema(responses={("200", "application/xml"): OpenApiTypes.BYTE})
-class OpenSearch1View(OPDSTemplateView):
+class OpenSearch1View(OPDSTemplateMixin, CodexAPIView):
     """OpenSearchView."""
 
     template_name = "opds_v1/opensearch_v1.xml"
     content_type = "application/xml"
-    throttle_classes = (ScopedRateThrottle,)
+    throttle_classes: Sequence[type[BaseThrottle]] = (ScopedRateThrottle,)
     throttle_scope = "opensearch"

codex/views/opds/v2/feed.py

@@ -4,13 +4,15 @@ from types import MappingProxyType
 
 from drf_spectacular.utils import extend_schema
 from rest_framework.response import Response
+from rest_framework.serializers import BaseSerializer
+from typing_extensions import override
 
-from codex.logger.logger import get_logger
+from codex.choices.admin import AdminFlagChoices
 from codex.models import AdminFlag
 from codex.serializers.browser.settings import OPDSSettingsSerializer
 from codex.serializers.opds.v2.feed import OPDS2FeedSerializer
-from codex.settings.settings import MAX_OBJ_PER_PAGE
-from codex.views.mixins import UserActiveViewMixin
+from codex.settings import MAX_OBJ_PER_PAGE
+from codex.views.mixins import UserActiveMixin
 from codex.views.opds.auth import OPDSAuthMixin
 from codex.views.opds.const import BLANK_TITLE
 from codex.views.opds.v2.const import (
@@ -25,20 +27,18 @@ from codex.views.opds.v2.href import HrefData
 from codex.views.opds.v2.links import LinkData
 from codex.views.opds.v2.publications import OPDS2PublicationView
 
-LOG = get_logger(__name__)
 
-
-class OPDS2FeedView(OPDSAuthMixin, OPDS2PublicationView, UserActiveViewMixin):
+class OPDS2FeedView(OPDSAuthMixin, UserActiveMixin, OPDS2PublicationView):
     """OPDS 2.0 Feed."""
 
     DEFAULT_ROUTE = MappingProxyType(
         {**OPDS2PublicationView.DEFAULT_ROUTE, "name": "opds:v2:feed"}
     )
-    TARGET = "opds2"
+    TARGET: str = "opds2"
     throttle_scope = "opds"
 
-    serializer_class = OPDS2FeedSerializer
-    input_serializer_class = OPDSSettingsSerializer
+    serializer_class: type[BaseSerializer] | None = OPDS2FeedSerializer
+    input_serializer_class: type[OPDSSettingsSerializer] = OPDSSettingsSerializer  # pyright: ignore[reportIncompatibleVariableOverride]
 
     def _title(self, browser_title):
         """Create the feed title."""
@@ -71,7 +71,7 @@ class OPDS2FeedView(OPDSAuthMixin, OPDS2PublicationView, UserActiveViewMixin):
             # Folder perms
             efv_flag = (
                 AdminFlag.objects.only("on")
-                .get(key=AdminFlag.FlagChoices.FOLDER_VIEW.value)
+                .get(key=AdminFlagChoices.FOLDER_VIEW.value)
                 .on
             )
             if not efv_flag:
@@ -164,8 +164,7 @@ class OPDS2FeedView(OPDSAuthMixin, OPDS2PublicationView, UserActiveViewMixin):
         groups += self._create_links_section(GROUPS, TOP_NAV_GROUP_SECTION_DATA)
 
         # Regular Groups
-        group_nav_dict = {"title": title, "links": group_qs}
-        tup = (NavigationGroup(**group_nav_dict),)
+        tup = (NavigationGroup(title=title, links=group_qs),)
         groups += self._create_links_section(tup, GROUPS_SECTION_DATA)
 
         # Publications
@@ -176,6 +175,7 @@ class OPDS2FeedView(OPDSAuthMixin, OPDS2PublicationView, UserActiveViewMixin):
     def _get_facets(self):
         return self._create_links_section(FACETS, FACETS_SECTION_DATA)
 
+    @override
     def get_object(self):
         """Get the browser page and serialize it for this subclass."""
         group_qs, book_qs, _, total_count, zero_pad, mtime = self.group_and_books
@@ -210,9 +210,8 @@ class OPDS2FeedView(OPDSAuthMixin, OPDS2PublicationView, UserActiveViewMixin):
             }
         )
 
-    @extend_schema(
-        parameters=[input_serializer_class],
-    )
+    @override
+    @extend_schema(parameters=[input_serializer_class])
     def get(self, *_args, **_kwargs):
         """Get the feed."""
         obj = self.get_object()

codex/views/opds/v2/href.py

@@ -1,14 +1,15 @@
 """Href methods for OPDS v2.0 Feed."""
 
-from abc import ABC
 from dataclasses import dataclass
+from typing import TYPE_CHECKING
 
 from django.urls import reverse
-from rest_framework.views import APIView
 
-from codex.views.opds.util import update_href_query_params
 from codex.views.util import pop_name
 
+if TYPE_CHECKING:
+    from rest_framework.request import Request
+
 
 @dataclass
 class HrefData:
@@ -22,7 +23,7 @@ class HrefData:
     max_page: int | None = None
 
 
-class OPDS2HrefMixin(APIView, ABC):
+class OPDS2HrefMixin:
     """Create links method."""
 
     @property
@@ -37,24 +38,28 @@ class OPDS2HrefMixin(APIView, ABC):
         page = int(kwargs["page"])
         return page >= min_page and page <= max_page
 
-    def _href_update_query_params(self, href, data):
+    def _href_update_query_params(self, data):
         """Update the query params."""
+        query = {}
         if data.absolute_query_params and data.query_params:
-            href = update_href_query_params(href, data.query_params)
+            query.update(data.query_params)
         elif hasattr(self, "request"):
             # if request link and not init static links
-            href = update_href_query_params(
-                href, self.request.GET, new_query_params=data.query_params
-            )
-        return href
+            if TYPE_CHECKING:
+                self.request: Request  # pyright: ignore[reportUninitializedInstanceVariable]
+            query.update(self.request.GET)
+            query.update(data.query_params)
+        return query
 
     def href(self, data):
         """Create an href."""
         url_name = data.url_name if data.url_name else "opds:v2:feed"
+        if TYPE_CHECKING:
+            self.kwargs: dict  # pyright: ignore[reportUninitializedInstanceVariable]
         kwargs = data.kwargs if data.kwargs is not None else self.kwargs
         if "page" in kwargs and not self._href_page_validate(kwargs, data):
             return None
 
         kwargs = pop_name(kwargs)
-        href = reverse(url_name, kwargs=kwargs)
-        return self._href_update_query_params(href, data)
+        query = self._href_update_query_params(data)
+        return reverse(url_name, kwargs=kwargs, query=query)

codex/views/opds/v2/links.py

@@ -7,8 +7,9 @@ from datetime import datetime
 from urllib.parse import parse_qsl, urlparse
 
 from django.db.models import QuerySet
+from typing_extensions import override
 
-from codex.settings.settings import FALSY
+from codex.settings import FALSY
 from codex.views.browser.browser import BrowserView
 from codex.views.opds.const import MimeType, Rel
 from codex.views.opds.v2.href import HrefData, OPDS2HrefMixin
@@ -52,6 +53,7 @@ class OPDS2LinksView(OPDS2HrefMixin, BrowserView):
         return self._group_and_books
 
     @property
+    @override
     def num_pages(self) -> int:
         """Memoize num_pages."""
         if self._num_pages is None:

codex/views/opds/v2/progression.py

@@ -2,43 +2,55 @@
 # https://github.com/opds-community/drafts/discussions/67#discussioncomment-6414507
 
 from types import MappingProxyType
+from typing import TYPE_CHECKING
 
 from django.db.models.expressions import F, Value
 from django.db.models.fields import FloatField
 from django.db.models.functions.comparison import Cast, Coalesce, Greatest, Least
 from django.db.models.query_utils import FilteredRelation
+from loguru import logger
 from rest_framework.exceptions import ValidationError
 from rest_framework.response import Response
+from rest_framework.serializers import BaseSerializer
+from typing_extensions import override
 
-from codex.logger.logger import get_logger
+from codex.models.comic import Comic
 from codex.serializers.opds.v2.progression import OPDS2ProgressionSerializer
 from codex.util import max_none
 from codex.views.auth import AuthFilterGenericAPIView
-from codex.views.bookmark import BookmarkFilterMixin, BookmarkPageView
+from codex.views.bookmark import BookmarkFilterMixin, BookmarkPageMixin
 from codex.views.const import GROUP_MODEL_MAP
 from codex.views.opds.v2.href import HrefData, OPDS2HrefMixin
 
+if TYPE_CHECKING:
+    from codex.models.groups import BrowserGroupModel
+
 _EMPTY_DEVICE = MappingProxyType(
     {
         "id": "",
         "name": "",
     }
 )
-LOG = get_logger(__name__)
 
 
 # This is an independent api requiring a separate get.
 class OPDS2ProgressionView(
-    BookmarkFilterMixin, OPDS2HrefMixin, BookmarkPageView, AuthFilterGenericAPIView
+    BookmarkFilterMixin, OPDS2HrefMixin, BookmarkPageMixin, AuthFilterGenericAPIView
 ):
     """OPDS 2 Progression view."""
 
-    serializer_class = OPDS2ProgressionSerializer
+    serializer_class: type[BaseSerializer] | None = OPDS2ProgressionSerializer
+
+    def __init__(self, *args, **kwargs):
+        """Initialize Bookmark Filter."""
+        self.init_bookmark_filter()
+        super().__init__(*args, **kwargs)
+        self._obj: BrowserGroupModel = Comic()
 
     @property
     def modified(self):
         """Get modified from bookmark."""
-        return self._obj.bookmark_updated_at  # type: ignore[reportAttributeAccessIssue]
+        return self._obj.bookmark_updated_at  # pyright: ignore[reportAttributeAccessIssue]
 
     @property
     def device(self):
@@ -49,16 +61,16 @@ class OPDS2ProgressionView(
     @property
     def title(self):
         """The locator title is the page number."""
-        return f"Page {self._obj.page}"  # type: ignore[reportAttributeAccessIssue]
+        return f"Page {self._obj.page}"  # pyright: ignore[reportAttributeAccessIssue]
 
     @property
     def _progression_href(self):
         """Build a Progression HRef."""
         acq_kwargs = {
             "pk": self._obj.pk,
-            "page": self._obj.page,  # type: ignore[reportAttributeAccessIssue]
+            "page": self._obj.page,  # pyright: ignore[reportAttributeAccessIssue]
         }
-        max_page = max_none(self._obj.page_count - 1, 0)  # type: ignore[reportAttributeAccessIssue]
+        max_page = max_none(self._obj.page_count - 1, 0)  # pyright: ignore[reportAttributeAccessIssue]
         data = HrefData(
             acq_kwargs,
             url_name="opds:bin:page",
@@ -71,9 +83,9 @@ class OPDS2ProgressionView(
     def _locations(self):
         """Build the Locations object."""
         return {
-            "position": self._obj.page,  # type: ignore[reportAttributeAccessIssue]
-            "progression": self._obj.progress,  # type: ignore[reportAttributeAccessIssue]
-            "total_progression": self._obj.progress,  # type: ignore[reportAttributeAccessIssue]
+            "position": self._obj.page,  # pyright: ignore[reportAttributeAccessIssue]
+            "progression": self._obj.progress,  # pyright: ignore[reportAttributeAccessIssue]
+            "total_progression": self._obj.progress,  # pyright: ignore[reportAttributeAccessIssue]
         }
 
     @property
@@ -86,12 +98,13 @@ class OPDS2ProgressionView(
             "locations": self._locations,
         }
 
+    @override
     def get_object(self):
         """Build the progression data object."""
         group = self.kwargs.get("group")
         pk = self.kwargs.get("pk")
 
-        if not pk:
+        if not (group and pk):
             reason = f"Bad primary key for {group}:{pk}"
             return ValidationError(reason, code="422")
 
@@ -130,7 +143,10 @@ class OPDS2ProgressionView(
             serializer = self.get_serializer(obj)
             return Response(serializer.data)
         except Exception:
-            LOG.exception("progression")
+            logger.exception("progression")
             raise
 
-    # PUT handled by BookmarkPageView parent
+    def put(self, *_args, **_kwargs):
+        """Update the bookmark."""
+        self.update_bookmark()
+        return Response()

codex/views/opds/v2/publications.py

@@ -7,27 +7,28 @@ from urllib.parse import quote_plus
 
 from codex.librarian.covers.create import THUMBNAIL_HEIGHT, THUMBNAIL_WIDTH
 from codex.models import Comic
-from codex.settings.settings import FALSY
+from codex.settings import FALSY
 from codex.views.opds.const import AUTHOR_ROLES, MimeType, Rel
-from codex.views.opds.util import get_contributors, get_m2m_objects
+from codex.views.opds.util import get_credits, get_m2m_objects
 from codex.views.opds.v2.href import HrefData
 from codex.views.opds.v2.links import LinkData
 from codex.views.opds.v2.top_links import OPDS2TopLinksView
 
-_MD_CONTRIBUTOR_MAP = MappingProxyType(
+_MD_CREDIT_MAP = MappingProxyType(
+    # If OPDS2 is ever popular, make this comprehensive by using comicbox role enums
     {
         "author": AUTHOR_ROLES,
-        # "translator": {}, unused
+        "translator": {"Translator"},
         "editor": {"Editor"},
-        "artist": {"CoverArtist"},
-        # "illustrator": {}, unused, could use penciller
+        "artist": {"CoverArtist", "Cover", "Artist"},
+        "illustrator": {"Illustrator"},
         "letterer": {"Letterer"},
         "penciller": {"Penciller"},
-        "colorist": {"Colorist"},
-        "inker": {"Inker"},
+        "colorist": {"Colorist", "Colors"},
+        "inker": {"Inker", "Inks"},
     }
 )
-_CONTRIBUTOR_ROLES = frozenset({x for s in _MD_CONTRIBUTOR_MAP.values() for x in s})
+_CREDIT_ROLES = frozenset({x for s in _MD_CREDIT_MAP.values() for x in s})
 
 
 class OPDS2PublicationView(OPDS2TopLinksView):
@@ -65,10 +66,10 @@ class OPDS2PublicationView(OPDS2TopLinksView):
         ]
 
     @staticmethod
-    def _add_contributors(md, pks, key, roles):
-        """Add contributors to metadata."""
-        if contributors := get_contributors(pks, roles, exclude=False):
-            md[key] = contributors
+    def _add_credits(md, pks, key, roles):
+        """Add credits to metadata."""
+        if credit_objs := get_credits(pks, roles, exclude=False):
+            md[key] = credit_objs
 
     def _publication_optional_metadata(self, md, obj):
         """Add optional Publication Metadtata."""
@@ -87,10 +88,10 @@ class OPDS2PublicationView(OPDS2TopLinksView):
 
     def _publication_extended_metadata(self, md, obj):
         """Publication m2m metadata only on the metadata alternate link."""
-        for key, roles in _MD_CONTRIBUTOR_MAP.items():
-            self._add_contributors(md, obj.ids, key, roles)
-        if contributors := get_contributors(obj.ids, _CONTRIBUTOR_ROLES, exclude=True):
-            md["contributor"] = contributors
+        for key, roles in _MD_CREDIT_MAP.items():
+            self._add_credits(md, obj.ids, key, roles)
+        if credit_objs := get_credits(obj.ids, _CREDIT_ROLES, exclude=True):
+            md["credit"] = credit_objs
 
         if m2m_objs := get_m2m_objects(obj.ids):
             # Subjects can also have links

codex/views/opds/v2/top_links.py

@@ -64,7 +64,7 @@ class OPDS2TopLinksView(OPDS2LinksView):
 
     def get_links(self, up_route):
         """Get the top links section of the feed."""
-        page = self.kwargs.get("page")
+        page = self.kwargs.get("page", 0)
         top_href_data = HrefData(self._top_route())
         top_link_data = LinkData(Rel.TOP, top_href_data)
         up_href_data = HrefData(up_route)
@@ -73,7 +73,12 @@ class OPDS2TopLinksView(OPDS2LinksView):
             self.link_self(),
             *self._get_static_links(),
             self._link_page("first", 1),
-            self._link_page("previous", page - 1),
+        ]
+        if page > 1:
+            links_data += [
+                self._link_page("previous", page - 1),
+            ]
+        links_data += [
             self._link_page("next", page + 1),
             self._link_page("last", self.num_pages),
             self.link(top_link_data),

codex/views/public.py

@@ -2,39 +2,36 @@
 
 from rest_framework.generics import GenericAPIView
 from rest_framework.mixins import RetrieveModelMixin
+from rest_framework.serializers import BaseSerializer
+from typing_extensions import override
 
-from codex.choices.admin import ADMIN_FLAG_CHOICES
-from codex.logger.logger import get_logger
+from codex.choices.admin import AdminFlagChoices
 from codex.models import AdminFlag
 from codex.serializers.auth import AuthAdminFlagsSerializer
 
-LOG = get_logger(__name__)
-_ADMIN_FLAG_KEYS = frozenset(
-    {
-        AdminFlag.FlagChoices.NON_USERS.value,
-        AdminFlag.FlagChoices.REGISTRATION.value,
-        AdminFlag.FlagChoices.BANNER_TEXT.value,
-    }
+_ADMIN_FLAG_KEYS = (
+    AdminFlagChoices.BANNER_TEXT.value,
+    AdminFlagChoices.LAZY_IMPORT_METADATA.value,
+    AdminFlagChoices.NON_USERS.value,
+    AdminFlagChoices.REGISTRATION.value,
 )
 
 
 class AdminFlagsView(GenericAPIView, RetrieveModelMixin):
     """Get admin flags relevant to auth."""
 
-    serializer_class = AuthAdminFlagsSerializer
+    serializer_class: type[BaseSerializer] | None = AuthAdminFlagsSerializer
     queryset = AdminFlag.objects.filter(key__in=_ADMIN_FLAG_KEYS).only(
         "key", "on", "value"
     )
 
+    @override
     def get_object(self):
         """Get admin flags."""
         flags = {}
         for obj in self.get_queryset():
-            name = ADMIN_FLAG_CHOICES[obj.key].lower().replace(" ", "_")
-            if obj.key == AdminFlag.FlagChoices.BANNER_TEXT.value:
-                val = obj.value
-            else:
-                val = obj.on
+            name = AdminFlagChoices(obj.key).name.lower()
+            val = obj.value if obj.key == AdminFlagChoices.BANNER_TEXT.value else obj.on
             flags[name] = val
         return flags