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

codex/views/opds/v2/links.py

@@ -1,30 +1,17 @@
 """Links methods for OPDS v2.0 Feed."""
 
+from collections.abc import Mapping
 from copy import deepcopy
 from dataclasses import dataclass
 from datetime import datetime
 from urllib.parse import parse_qsl, urlparse
 
 from django.db.models import QuerySet
-from django.urls import reverse
 
 from codex.settings.settings import FALSY
 from codex.views.browser.browser import BrowserView
 from codex.views.opds.const import MimeType, Rel
-from codex.views.opds.util import update_href_query_params
-from codex.views.util import pop_name
-
-
-@dataclass
-class HrefData:
-    """Data for creating hrefs."""
-
-    kwargs: dict | None = None
-    query_params: dict | None = None
-    absolute_query_params: bool = False
-    url_name: str | None = None
-    min_page: int | None = None
-    max_page: int | None = None
+from codex.views.opds.v2.href import HrefData, OPDS2HrefMixin
 
 
 @dataclass
@@ -40,9 +27,10 @@ class LinkData:
     width: int | None = None
     href: str | None = None
     num_items: int | None = None
+    authenticate: Mapping | None = None
 
 
-class OPDS2LinksView(BrowserView):
+class OPDS2LinksView(OPDS2HrefMixin, BrowserView):
     """Links methods for OPDS 2.0 Feed."""
 
     def __init__(self, *args, **kwargs):
@@ -70,41 +58,12 @@ class OPDS2LinksView(BrowserView):
             self._num_pages = self.group_and_books[2]
         return self._num_pages
 
-    def _href_page_validate(self, kwargs, data):
-        """Validate the page bounds."""
-        min_page = 1 if data.min_page is None else data.min_page
-        max_page = self.num_pages if data.max_page is None else data.max_page
-        page = int(kwargs["page"])
-        return page >= min_page and page <= max_page
-
-    def _href_update_query_params(self, href, data):
-        """Update the query params."""
-        if data.absolute_query_params and data.query_params:
-            href = update_href_query_params(href, 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
-
-    def _href(self, data):
-        """Create an href."""
-        url_name = data.url_name if data.url_name else "opds:v2:feed"
-        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)
-
     def link(self, data):
         """Create a link element."""
         if data.href:
             href = data.href
         else:
-            href = self._href(data.href_data)
+            href = self.href(data.href_data)
             if not href:
                 return None
         mime_type = data.mime_type if data.mime_type else MimeType.OPDS_JSON
@@ -118,8 +77,15 @@ class OPDS2LinksView(BrowserView):
             link["height"] = data.height
         if data.width:
             link["width"] = data.width
+
+        # Properties
+        if data.num_items or data.authenticate:
+            link["properties"] = {}
         if data.num_items:
-            link["properties"] = {"number_of_items": data.num_items}
+            link["properties"]["number_of_items"] = data.num_items
+        if data.authenticate:
+            link["properties"]["authenticate"] = data.authenticate
+
         return link
 
     @staticmethod

codex/views/opds/v2/progression.py

@@ -0,0 +1,136 @@
+"""OPDS 2 Progression view."""
+# https://github.com/opds-community/drafts/discussions/67#discussioncomment-6414507
+
+from types import MappingProxyType
+
+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 rest_framework.exceptions import ValidationError
+from rest_framework.response import Response
+
+from codex.logger.logging import get_logger
+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.const import GROUP_MODEL_MAP
+from codex.views.opds.v2.href import HrefData, OPDS2HrefMixin
+
+_EMPTY_DEVICE = MappingProxyType(
+    {
+        "id": "",
+        "name": "",
+    }
+)
+LOG = get_logger(__name__)
+
+
+# This is an independent api requiring a separate get.
+class OPDS2ProgressionView(
+    BookmarkFilterMixin, OPDS2HrefMixin, BookmarkPageView, AuthFilterGenericAPIView
+):
+    """OPDS 2 Progression view."""
+
+    serializer_class = OPDS2ProgressionSerializer
+
+    @property
+    def modified(self):
+        """Get modified from bookmark."""
+        return self._obj.bookmark_updated_at  # type: ignore[reportAttributeAccessIssue]
+
+    @property
+    def device(self):
+        """Dummy device."""
+        # Codex doesn't record this.
+        return _EMPTY_DEVICE
+
+    @property
+    def title(self):
+        """The locator title is the page number."""
+        return f"Page {self._obj.page}"  # type: ignore[reportAttributeAccessIssue]
+
+    @property
+    def _progression_href(self):
+        """Build a Progression HRef."""
+        acq_kwargs = {
+            "pk": self._obj.pk,
+            "page": self._obj.page,  # type: ignore[reportAttributeAccessIssue]
+        }
+        max_page = max_none(self._obj.page_count - 1, 0)  # type: ignore[reportAttributeAccessIssue]
+        data = HrefData(
+            acq_kwargs,
+            url_name="opds:bin:page",
+            min_page=0,
+            max_page=max_page,
+        )
+        return self.href(data)
+
+    @property
+    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]
+        }
+
+    @property
+    def locator(self):
+        """Build the Locator object."""
+        return {
+            "title": self.title,  # See publication.py:103
+            "href": self._progression_href,
+            "type": "image/jpeg",
+            "locations": self._locations,
+        }
+
+    def get_object(self):
+        """Build the progression data object."""
+        group = self.kwargs.get("group")
+        pk = self.kwargs.get("pk")
+
+        if not pk:
+            reason = f"Bad primary key for {group}:{pk}"
+            return ValidationError(reason, code="422")
+
+        model = GROUP_MODEL_MAP.get(group)
+        if not model:
+            reason = f"No model found for group {group}"
+            raise ValidationError(reason, code="422")
+
+        acl_filter = self.get_group_acl_filter(model, self.request.user)
+        qs = model.objects.filter(acl_filter).distinct()
+
+        bm_rel = self.get_bm_rel(model)
+        bm_filter = self.get_my_bookmark_filter(bm_rel)
+        progress = Least(
+            F("page") / Greatest(Cast(F("page_count"), FloatField()), 1.0), Value(1.0)
+        )
+
+        qs = qs.annotate(
+            my_bookmark=FilteredRelation("bookmark", condition=bm_filter),
+            bookmark_updated_at=F("my_bookmark__updated_at"),
+            page=Coalesce(F("my_bookmark__page"), 0),
+            progress=progress,
+        )
+        self._obj = qs.only("page_count").distinct().get(pk=pk)
+
+        return {
+            "modified": self.modified,
+            "device": self.device,
+            "locator": self.locator,
+        }
+
+    def get(self, *args, **kwargs):
+        """Get Response."""
+        try:
+            obj = self.get_object()
+            serializer = self.get_serializer(obj)
+            return Response(serializer.data)
+        except Exception:
+            LOG.exception("progression")
+            raise
+
+    # PUT handled by BookmarkPageView parent

codex/views/opds/v2/publications.py

@@ -10,15 +10,17 @@ from codex.models import Comic
 from codex.settings.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.v2.top_links import HrefData, LinkData, OPDS2TopLinksView
+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(
     {
         "author": AUTHOR_ROLES,
-        # "translator": {},
+        # "translator": {}, unused
         "editor": {"Editor"},
         "artist": {"CoverArtist"},
-        # "illustrator": {},
+        # "illustrator": {}, unused, could use penciller
         "letterer": {"Letterer"},
         "penciller": {"Penciller"},
         "colorist": {"Colorist"},
@@ -40,7 +42,9 @@ class OPDS2PublicationView(OPDS2TopLinksView):
             "dynamicCovers": False,
             "ts": ts,
         }
-        href_data = HrefData(kwargs, query_params, True, "opds:bin:cover")
+        href_data = HrefData(
+            kwargs, query_params, absolute_query_params=True, url_name="opds:bin:cover"
+        )
         link_data = LinkData(
             Rel.THUMBNAIL,
             href_data,
@@ -63,15 +67,13 @@ class OPDS2PublicationView(OPDS2TopLinksView):
     @staticmethod
     def _add_contributors(md, pks, key, roles):
         """Add contributors to metadata."""
-        if contributors := get_contributors(pks, roles):
+        if contributors := get_contributors(pks, roles, exclude=False):
             md[key] = contributors
 
     def _publication_optional_metadata(self, md, obj):
         """Add optional Publication Metadtata."""
         if subtitle := obj.name:
             md["subtitle"] = subtitle
-        # if identifier := obj.get("guid")
-        #   md["identifier"] = identifier
         if desc := obj.summary:
             md["description"] = desc
         if lang := obj.language:
@@ -87,25 +89,21 @@ class OPDS2PublicationView(OPDS2TopLinksView):
         """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, True):
+        if contributors := get_contributors(obj.ids, _CONTRIBUTOR_ROLES, exclude=True):
             md["contributor"] = contributors
 
         if m2m_objs := get_m2m_objects(obj.ids):
-            # XXX Subjects can also have links
+            # Subjects can also have links
             # https://readium.org/webpub-manifest/schema/subject-object.schema.json
-            subjects = []
-            for subjs in m2m_objs.values():
-                for subj in subjs:
-                    subjects.append(subj.name)
-            md["subject"] = subjects
+            md["subject"] = [subj.name for subjs in m2m_objs.values() for subj in subjs]
 
     def _publication_metadata(self, obj, zero_pad):
         title = Comic.get_title(
             obj,
             volume=False,
             name=False,
-            zero_pad=zero_pad,
             filename_fallback=self.title_filename_fallback,
+            zero_pad=zero_pad,
         )
         md = {
             "type": MimeType.BOOK,
@@ -127,10 +125,6 @@ class OPDS2PublicationView(OPDS2TopLinksView):
         download_mime_type = MimeType.FILE_TYPE_MAP.get(obj.file_type, MimeType.OCTET)
         self_kwargs = {"pk": obj.pk, "page": 1}
 
-        # This would be for comic streaming which is not supported by OPDS 2 yet?
-        # self_href_data = HrefData(self_kwargs, absolute_query_params=True)
-        # self_link_data = LinkData(Rel.SELF, self_href_data, mime_type=MimeType.OPDS_PUB)
-
         alt_kwargs = self_kwargs
         alt_href_data = HrefData(
             alt_kwargs,
@@ -154,11 +148,27 @@ class OPDS2PublicationView(OPDS2TopLinksView):
             acq_href_data,
             mime_type=download_mime_type,
         )
+        prog_kwargs = {"group": "c", "pk": obj.pk}
+        prog_href_data = HrefData(prog_kwargs, url_name="opds:v2:position")
+
+        auth_href_data = HrefData({}, url_name="opds:authentication:v1")
+        auth_link_data = LinkData(
+            Rel.AUTHENTICATION,
+            auth_href_data,
+            mime_type=MimeType.AUTHENTICATION,
+        )
+        auth_link = self.link(auth_link_data)
+
+        prog_link_data = LinkData(
+            Rel.PROGRESSION,
+            prog_href_data,
+            mime_type=MimeType.PROGRESSION,
+            authenticate=auth_link,
+        )
         links = [
-            # Comic streaming link (unsupported)
-            # self.link(self_link_data),
             self.link(alt_link_data),
             self.link(acq_link_data),
+            self.link(prog_link_data),
         ]
         pub["links"] = links
 

codex/views/opds/v2/top_links.py

@@ -1,7 +1,8 @@
 """OPDS v2.0 top links section methods."""
 
 from codex.views.opds.const import MimeType, Rel
-from codex.views.opds.v2.links import HrefData, LinkData, OPDS2LinksView
+from codex.views.opds.v2.href import HrefData
+from codex.views.opds.v2.links import LinkData, OPDS2LinksView
 
 
 class OPDS2TopLinksView(OPDS2LinksView):

codex/views/public.py

@@ -13,6 +13,7 @@ _ADMIN_FLAG_KEYS = frozenset(
     {
         AdminFlag.FlagChoices.NON_USERS.value,
         AdminFlag.FlagChoices.REGISTRATION.value,
+        AdminFlag.FlagChoices.BANNER_TEXT.value,
     }
 )
 
@@ -21,16 +22,22 @@ class AdminFlagsView(GenericAPIView, RetrieveModelMixin):
     """Get admin flags relevant to auth."""
 
     serializer_class = AuthAdminFlagsSerializer
-    queryset = AdminFlag.objects.filter(key__in=_ADMIN_FLAG_KEYS).only("key", "on")
+    queryset = AdminFlag.objects.filter(key__in=_ADMIN_FLAG_KEYS).only(
+        "key", "on", "value"
+    )
 
     def get_object(self):
         """Get admin flags."""
         flags = {}
-        for obj in self.get_queryset():  # type: ignore
+        for obj in self.get_queryset():
             name = ADMIN_FLAG_CHOICES[obj.key].lower().replace(" ", "_")
-            flags[name] = obj.on
+            if obj.key == AdminFlag.FlagChoices.BANNER_TEXT.value:
+                val = obj.value
+            else:
+                val = obj.on
+            flags[name] = val
         return flags
 
-    def get(self, request, *args, **kwargs):
+    def get(self, *args, **kwargs):
         """Get admin flags relevant to auth."""
-        return self.retrieve(request, *args, **kwargs)
+        return self.retrieve(*args, **kwargs)

codex/views/reader/books.py

@@ -6,7 +6,7 @@ from django.db.models import F
 from django.db.models.query import Q
 
 from codex.models import Bookmark, Comic
-from codex.views.bookmark import BookmarkBaseView
+from codex.views.bookmark import BookmarkAuthMixin
 from codex.views.browser.filters.field import ComicFieldFilterView
 from codex.views.const import (
     FOLDER_GROUP,
@@ -15,7 +15,7 @@ from codex.views.const import (
     NONE_INTEGERFIELD,
     STORY_ARC_GROUP,
 )
-from codex.views.mixins import BookmarkSearchMixin, SharedAnnotationsMixin
+from codex.views.mixins import SharedAnnotationsMixin
 from codex.views.reader.params import ReaderParamsView
 
 if TYPE_CHECKING:
@@ -34,9 +34,7 @@ _COMIC_FIELDS = (
 )
 
 
-class ReaderBooksView(
-    BookmarkBaseView, ReaderParamsView, SharedAnnotationsMixin, BookmarkSearchMixin
-):
+class ReaderBooksView(SharedAnnotationsMixin, BookmarkAuthMixin, ReaderParamsView):
     """Get Books methods."""
 
     def _get_reader_arc_pks(
@@ -81,10 +79,10 @@ class ReaderBooksView(
         """Get ordering for query."""
         sort_name_annotations = {}
         if arc_group in ("v", "s"):
+            parent_group = "i" if arc_group == "s" else "s"
             show = self.params["show"]
-            model_group = "i" if arc_group == "s" else "s"
             sort_name_annotations = self.get_sort_name_annotations(
-                model, model_group, arc_pks, show
+                model, parent_group, arc_pks, show
             )
             if sort_name_annotations and model is Comic:
                 ordering += (*sort_name_annotations.keys(),)
@@ -97,7 +95,7 @@ class ReaderBooksView(
 
     def _get_comics_list(self):
         """Get the reader naviation group filter."""
-        arc: Mapping = self.params.get("arc", {})  # type: ignore
+        arc: Mapping = self.params.get("arc", {})
 
         arc_group = arc.get("group", "")
         if not GROUP_MODEL_MAP.get(arc_group):
@@ -149,6 +147,19 @@ class ReaderBooksView(
         qs = qs.order_by(*ordering)
         return qs, arc_group
 
+    @staticmethod
+    def _get_bookmark_filter(auth_filter, comic_filter=None):
+        """Get the search kwargs for a user's authentication state."""
+        # search kwargs are relative to the bookmark object.
+        search_kwargs = {}
+        search_kwargs.update(auth_filter)
+
+        if comic_filter:
+            for key, value in comic_filter.items():
+                search_kwargs[f"comic__{key}"] = value
+
+        return search_kwargs
+
     def _append_with_settings(self, book, bookmark_filter):
         """Append bookmark to book list."""
         book.settings = (
@@ -159,7 +170,8 @@ class ReaderBooksView(
         return book
 
     def get_book_collection(self):
-        """Get the -1, +1 window around the current issue.
+        """
+        Get the -1, +1 window around the current issue.
 
         Uses iteration in python. There are some complicated ways of
         doing this with __gt[0] & __lt[0] in the db, but I think they
@@ -169,7 +181,7 @@ class ReaderBooksView(
         """
         comics, arc_group = self._get_comics_list()
         auth_filter = self.get_bookmark_auth_filter()
-        bookmark_filter = self.get_bookmark_search_kwargs(auth_filter)
+        bookmark_filter = self._get_bookmark_filter(auth_filter)
         books = {}
         prev_book = None
         pk = self.kwargs.get("pk")

codex/views/reader/page.py

@@ -14,7 +14,8 @@ from codex.librarian.mp_queue import LIBRARIAN_QUEUE
 from codex.logger.logging import get_logger
 from codex.models.comic import Comic, FileType
 from codex.settings.settings import FALSY
-from codex.views.bookmark import BookmarkBaseView
+from codex.views.auth import AuthFilterAPIView
+from codex.views.bookmark import BookmarkAuthMixin
 from codex.views.util import chunker
 
 LOG = get_logger(__name__)
@@ -31,23 +32,23 @@ class IgnoreClientContentNegotiation(BaseContentNegotiation):
         """Select the first parser in the `.parser_classes` list."""
         return next(iter(parsers))
 
-    def select_renderer(  # type: ignore
+    def select_renderer(
         self,
         request,  # noqa: ARG002
         renderers,
-        _format_suffix="",
+        format_suffix="",  # noqa: ARG002, F841, RUF100
     ):
         """Select the first renderer in the `.renderer_classes` list."""
         renderer = next(iter(renderers))
         return (renderer, renderer.media_type)
 
 
-class ReaderPageView(BookmarkBaseView):
+class ReaderPageView(BookmarkAuthMixin, AuthFilterAPIView):
     """Display a comic page from the archive itself."""
 
     X_MOZ_PRE_HEADERS = frozenset({"prefetch", "preload", "prerender", "subresource"})
     content_type = "image/jpeg"
-    content_negotiation_class = IgnoreClientContentNegotiation  # type: ignore
+    content_negotiation_class = IgnoreClientContentNegotiation  # type: ignore[reportAssignmentType]
 
     def _update_bookmark(self):
         """Update the bookmark if the bookmark param was passed."""
@@ -59,12 +60,11 @@ class ReaderPageView(BookmarkBaseView):
             return
 
         auth_filter = self.get_bookmark_auth_filter()
-        pk = self.kwargs.get("pk")
-        comic_filter = {"pk": pk}
+        comic_pks = (self.kwargs.get("pk"),)
         page = self.kwargs.get("page")
         updates = {"page": page}
 
-        task = BookmarkUpdateTask(auth_filter, comic_filter, updates)
+        task = BookmarkUpdateTask(auth_filter, comic_pks, updates)
         LIBRARIAN_QUEUE.put(task)
 
     def _get_page_image(self):

codex/views/reader/params.py

@@ -121,9 +121,9 @@ class ReaderParamsView(SessionView):
                 serializer = self.input_serializer_class(data=data)
                 serializer.is_valid(raise_exception=True)
 
-                params: dict = mapping_to_dict(_DEFAULT_PARAMS)  # type: ignore
+                params: dict[str, Any] = mapping_to_dict(_DEFAULT_PARAMS)  # type: ignore[reportAssignmentType]
                 if serializer.validated_data:
-                    params.update(serializer.validated_data)  # type: ignore
+                    params.update(serializer.validated_data)
                 self._ensure_arc_contains_comic(params)
                 self._ensure_arc(params)
 

codex/views/reader/reader.py

@@ -58,7 +58,7 @@ class ReaderView(ReaderArcsView):
             task = LazyImportComicsTask(frozenset(import_pks))
             LIBRARIAN_QUEUE.put(task)
 
-    def get_object(self):  # type: ignore
+    def get_object(self):
         """Get the previous and next comics in a group or story arc."""
         # Books
         books = self.get_book_collection()
@@ -82,13 +82,13 @@ class ReaderView(ReaderArcsView):
 
         arc = self.params.get("arc", {})
         if not arc.get("group"):
-            arc["group"] = current.arc_group  # type: ignore
+            arc["group"] = current.arc_group
         if not arc.get("pks"):
-            arc["pks"] = (current.arc_pk,)  # type: ignore
-        arc["index"] = current.arc_index  # type:ignore
-        arc["count"] = current.arc_count  # type: ignore
+            arc["pks"] = (current.arc_pk,)
+        arc["index"] = current.arc_index
+        arc["count"] = current.arc_count
 
-        close_route = self.get_last_route()
+        close_route = self.get_last_route(name=True)
 
         return {
             "books": books,

codex/views/reader/settings.py

@@ -7,6 +7,6 @@ from codex.views.settings import SettingsView
 class ReaderSettingsView(SettingsView):
     """Get Reader Settings."""
 
-    serializer_class = ReaderSettingsSerializer  # type: ignore
+    serializer_class = ReaderSettingsSerializer
 
     SESSION_KEY = "reader"

codex/views/session.py

@@ -3,6 +3,7 @@
 from abc import ABC
 from copy import deepcopy
 from types import MappingProxyType
+from typing import TYPE_CHECKING
 
 from codex.choices import BROWSER_DEFAULTS, READER_DEFAULTS
 from codex.logger.logging import get_logger
@@ -10,6 +11,9 @@ from codex.util import mapping_to_dict
 from codex.views.auth import AuthFilterGenericAPIView
 from codex.views.util import pop_name
 
+if TYPE_CHECKING:
+    from collections.abc import Mapping
+
 LOG = get_logger(__name__)
 
 CONTRIBUTOR_PERSON_UI_FIELD = "contributors"
@@ -78,13 +82,15 @@ class SessionView(AuthFilterGenericAPIView, ABC):
             default = self.SESSION_DEFAULTS[session_key][key]
         return session.get(key, default)
 
-    def get_last_route(self, name=True):
+    def get_last_route(self, name: bool):
         """Get the last route from the breadcrumbs."""
         breadcrumbs = self.get_from_session(
             "breadcrumbs", session_key=self.BROWSER_SESSION_KEY
         )
         if not breadcrumbs:
-            default_breadcrumbs: tuple[dict] = BROWSER_DEFAULTS["breadcrumbs"]  # type: ignore
+            default_breadcrumbs: tuple[
+                Mapping[str, str | tuple[int, ...] | int], ...
+            ] = BROWSER_DEFAULTS["breadcrumbs"]  # type: ignore[reportAssignmentType]
             breadcrumbs = default_breadcrumbs
         last_route = breadcrumbs[-1]
         if not name:

codex/views/settings.py

@@ -29,7 +29,7 @@ class SettingsView(SessionView, ABC):
         serializer = self.input_serializer_class(data=data)
         serializer.is_valid(raise_exception=True)
         validated_data = serializer.validated_data
-        only = validated_data.get("only") if validated_data else None  # type: ignore
+        only = validated_data.get("only") if validated_data else None
         params = self.load_params_from_session(only=only)
         params = self.validate_settings_get(validated_data, params)
         serializer = self.get_serializer(params)
@@ -38,7 +38,7 @@ class SettingsView(SessionView, ABC):
     @extend_schema(responses=None)
     def patch(self, *args, **kwargs):
         """Update session settings."""
-        data = self.request.data  # type: ignore
+        data = self.request.data
         serializer = self.get_serializer(data=data)
         serializer.is_valid(raise_exception=True)
         params = self.load_params_from_session()

codex/views/timezone.py

@@ -28,11 +28,11 @@ class TimezoneView(AuthGenericAPIView):
     @extend_schema(request=input_serializer_class)
     def put(self, *args, **kwargs):
         """Get the user info for the current user."""
-        data = self.request.data  # type: ignore
+        data = self.request.data
         serializer = self.input_serializer_class(data=data)
         serializer.is_valid(raise_exception=True)
         try:
-            timezone = serializer.validated_data.get("timezone")  # type: ignore
+            timezone = serializer.validated_data.get("timezone")
             self._save_timezone(timezone)
         except Exception as exc:
             reason = f"update user timezone {exc}"