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

codex/views/auth.py

@@ -1,26 +1,28 @@
 """Views authorization bases."""
 
+from collections.abc import Sequence
+
 from django.contrib.auth.models import AnonymousUser
 from django.db.models import Q
 from rest_framework.generics import GenericAPIView
-from rest_framework.permissions import IsAuthenticated
+from rest_framework.permissions import BasePermission, IsAuthenticated
 from rest_framework.views import APIView
+from typing_extensions import override
 
-from codex.logger.logger import get_logger
+from codex.choices.admin import AdminFlagChoices
 from codex.models import AdminFlag, Comic, Folder, StoryArc
 
-LOG = get_logger(__name__)
-
 
 class IsAuthenticatedOrEnabledNonUsers(IsAuthenticated):
     """Custom DRF Authentication class."""
 
     code = 403
 
+    @override
     def has_permission(self, request, view):
         """Return True if ENABLE_NON_USERS is true or user authenticated."""
         enu_flag = AdminFlag.objects.only("on").get(
-            key=AdminFlag.FlagChoices.NON_USERS.value
+            key=AdminFlagChoices.NON_USERS.value
         )
         if enu_flag.on:
             return True
@@ -30,25 +32,31 @@ class IsAuthenticatedOrEnabledNonUsers(IsAuthenticated):
 class AuthMixin:
     """General Auth Policy."""
 
-    permission_classes = (IsAuthenticatedOrEnabledNonUsers,)
+    permission_classes: Sequence[type[BasePermission]] = (
+        IsAuthenticatedOrEnabledNonUsers,
+    )
 
 
-class AuthAPIView(AuthMixin, APIView):
+class AuthAPIView(AuthMixin, APIView):  # pyright: ignore[reportIncompatibleVariableOverride]
     """Auth Policy APIView."""
 
 
-class AuthGenericAPIView(AuthMixin, GenericAPIView):
+class AuthGenericAPIView(AuthMixin, GenericAPIView):  # pyright: ignore[reportIncompatibleVariableOverride]
     """Auth Policy GenericAPIView."""
 
 
-class GroupACLMixin(APIView):
-    """Filter group ACLS for views."""
+class GroupACLMixin:
+    """Filter group mixin for views and threads."""
+
+    def init_group_acl(self):
+        """Initialize properties."""
+        self._is_admin: bool | None = None  # pyright: ignore[reportUninitializedInstanceVariable]
 
     @property
     def is_admin(self):
         """Is the current user an admin."""
         if self._is_admin is None:
-            user = self.request.user
+            user = self.request.user  # pyright: ignore[reportAttributeAccessIssue]
             self._is_admin = user and getattr(user, "is_staff", False)
         return self._is_admin
 
@@ -99,6 +107,16 @@ class GroupACLMixin(APIView):
 class AuthFilterGenericAPIView(AuthGenericAPIView, GroupACLMixin):
     """Auth Enabled GenericAPIView."""
 
+    def __init__(self, *args, **kwargs):
+        """Iniit acl properties."""
+        super().__init__(*args, **kwargs)
+        self.init_group_acl()
+
 
 class AuthFilterAPIView(AuthAPIView, GroupACLMixin):
     """Auth Enabled APIView."""
+
+    def __init__(self, *args, **kwargs):
+        """Iniit acl properties."""
+        super().__init__(*args, **kwargs)
+        self.init_group_acl()

codex/views/bookmark.py

@@ -4,26 +4,26 @@ from abc import ABC
 from typing import TYPE_CHECKING
 
 from django.db.models import Q
+from loguru import logger
 from rest_framework.response import Response
-from rest_framework.views import APIView
 
 from codex.librarian.bookmark.tasks import BookmarkUpdateTask
 from codex.librarian.mp_queue import LIBRARIAN_QUEUE
-from codex.logger.logger import get_logger
 from codex.views.auth import AuthAPIView, GroupACLMixin
 
 if TYPE_CHECKING:
-    from codex.models import BrowserGroupModel
+    from rest_framework.request import Request
 
-LOG = get_logger(__name__)
+    from codex.models import BrowserGroupModel
 
 
 class BookmarkFilterMixin(GroupACLMixin, ABC):
     """Bookmark filter methods."""
 
-    def __init__(self, *args, **kwargs):
+    def init_bookmark_filter(self):
         """Initialize the bm_annotation_data."""
-        super().__init__(*args, **kwargs)
+        if TYPE_CHECKING:
+            self.request: Request
         self._bm_rels: dict[BrowserGroupModel, str] = {}
         self._bm_filters: dict[BrowserGroupModel, Q] = {}
 
@@ -46,37 +46,48 @@ class BookmarkFilterMixin(GroupACLMixin, ABC):
         return Q(**my_bookmarks_kwargs)
 
 
-class BookmarkAuthMixin(APIView):
+class BookmarkAuthMixin:
     """Base class for Bookmark Views."""
 
     def get_bookmark_auth_filter(self) -> dict[str, int | str | None]:
         """Filter only the user's bookmarks."""
+        if TYPE_CHECKING:
+            self.request: Request  # pyright: ignore[reportUninitializedInstanceVariable]
         if self.request.user.is_authenticated:
             key = "user_id"
             value = self.request.user.pk
         else:
             if not self.request.session or not self.request.session.session_key:
-                LOG.debug("no session, make one")
+                logger.debug("no session, make one")
                 self.request.session.save()
             key = "session_id"
             value = self.request.session.session_key
         return {key: value}
 
 
-class BookmarkPageView(BookmarkAuthMixin, AuthAPIView):
-    """Display a comic page from the archive itself."""
+class BookmarkPageMixin(BookmarkAuthMixin):
+    """Update the bookmark if the bookmark param was passed."""
 
-    def _update_bookmark(self):
+    def update_bookmark(self):
         """Update the bookmark if the bookmark param was passed."""
+        if TYPE_CHECKING:
+            self.kwargs: dict  # pyright: ignore[reportUninitializedInstanceVariable]
         auth_filter = self.get_bookmark_auth_filter()
-        comic_pks = (self.kwargs.get("pk"),)
+        comic_pks = []
+        if comic_pk := self.kwargs.get("pk"):
+            comic_pk.append(comic_pk)
+        comic_pks = tuple(comic_pks)
         page = self.kwargs.get("page")
         updates = {"page": page}
 
         task = BookmarkUpdateTask(auth_filter, comic_pks, updates)
         LIBRARIAN_QUEUE.put(task)
 
+
+class BookmarkPageView(BookmarkPageMixin, AuthAPIView):
+    """Display a comic page from the archive itself."""
+
     def put(self, *_args, **_kwargs):
-        """Get the comic page from the archive."""
-        self._update_bookmark()
+        """Update the bookmark."""
+        self.update_bookmark()
         return Response()

codex/views/browser/annotate/bookmark.py

@@ -11,15 +11,12 @@ from django.db.models.fields import BooleanField, PositiveSmallIntegerField
 from django.db.models.functions import Least
 from django.db.models.functions.comparison import Coalesce, Greatest
 
-from codex.logger.logger import get_logger
 from codex.models import (
     Comic,
 )
 from codex.models.functions import JsonGroupArray
 from codex.views.browser.annotate.order import BrowserAnnotateOrderView
 
-LOG = get_logger(__name__)
-
 
 class BrowserAnnotateBookmarkView(BrowserAnnotateOrderView):
     """Base class for views that need special metadata annotations."""

codex/views/browser/annotate/card.py

@@ -8,16 +8,23 @@ from django.db.models import (
 )
 from django.db.models.fields import CharField
 
-from codex.logger.logger import get_logger
 from codex.models.comic import Comic
 from codex.models.functions import JsonGroupArray
 from codex.models.groups import BrowserGroupModel, Imprint, Publisher, Series, Volume
+from codex.models.named import StoryArc
 from codex.views.browser.annotate.bookmark import BrowserAnnotateBookmarkView
 
-_GROUP_BY: MappingProxyType[type[BrowserGroupModel], str] = MappingProxyType(
-    {Publisher: "sort_name", Imprint: "sort_name", Series: "sort_name", Volume: "name"}
+_GROUP_BY: MappingProxyType[type[BrowserGroupModel], tuple[str, ...]] = (
+    MappingProxyType(
+        {
+            Publisher: ("sort_name",),
+            Imprint: ("sort_name",),
+            Series: ("sort_name",),
+            Volume: ("name", "number_to"),
+            StoryArc: ("sort_name",),
+        }
+    )
 )
-LOG = get_logger(__name__)
 
 
 class BrowserAnnotateCardView(BrowserAnnotateBookmarkView):
@@ -25,8 +32,9 @@ class BrowserAnnotateCardView(BrowserAnnotateBookmarkView):
 
     def add_group_by(self, qs):
         """Get the group by for the model."""
+        # this method is here because this is class is what metadata imports
         if group_by := _GROUP_BY.get(qs.model):
-            qs = qs.group_by(group_by)
+            qs = qs.group_by(*group_by)
         return qs
 
     def _annotate_group(self, qs):
@@ -44,6 +52,12 @@ class BrowserAnnotateCardView(BrowserAnnotateBookmarkView):
             file_name = self.get_filename_func(qs.model)
         return qs.annotate(file_name=file_name)
 
+    def _annotate_has_metadata(self, qs):
+        """Annotate if we have metadata."""
+        if qs.model is Comic:
+            qs = qs.annotate(has_metadata=F("metadata_mtime"))
+        return qs
+
     def annotate_card_aggregates(self, qs):
         """Annotate aggregates that appear the browser card."""
         if qs.model is Comic:
@@ -55,4 +69,5 @@ class BrowserAnnotateCardView(BrowserAnnotateBookmarkView):
         qs = self.annotate_child_count(qs)
         qs = self.annotate_bookmarks(qs)
         qs = self.annotate_progress(qs)
+        qs = self._annotate_has_metadata(qs)
         return qs.annotate(updated_ats=JsonGroupArray("updated_at", distinct=True))

codex/views/browser/annotate/order.py

@@ -13,7 +13,6 @@ from django.db.models.aggregates import Avg, Count, Max, Min, Sum
 from django.db.models.fields import CharField
 from django.db.models.functions import Reverse, Right, StrIndex
 
-from codex.logger.logger import get_logger
 from codex.models import (
     Comic,
     Folder,
@@ -34,7 +33,6 @@ _ORDER_AGGREGATE_FUNCS = MappingProxyType(
     {
         "age_rating": Avg,
         "child_count": Min,
-        "community_rating": Avg,
         "created_at": Min,
         "critical_rating": Avg,
         "date": Min,
@@ -55,8 +53,6 @@ _ANNOTATED_ORDER_FIELDS = frozenset(
     }
 )
 
-LOG = get_logger(__name__)
-
 
 class BrowserAnnotateOrderView(BrowserOrderByView, SharedAnnotationsMixin):
     """Base class for views that need special metadata annotations."""
@@ -131,8 +127,8 @@ class BrowserAnnotateOrderView(BrowserOrderByView, SharedAnnotationsMixin):
 
         return Right(
             path_rel,
-            StrIndex(
-                Reverse(F(path_rel)),  # type: ignore[reportArgumentType]
+            StrIndex(  # pyright: ignore[reportArgumentType]
+                Reverse(F(path_rel)),
                 Value(sep),
             )
             - 1,
@@ -247,7 +243,7 @@ class BrowserAnnotateOrderView(BrowserOrderByView, SharedAnnotationsMixin):
             )
             order_value = F(order_key)
         elif self.order_key in _ANNOTATED_ORDER_FIELDS:
-            # These are annotated in browser_annotaions
+            # These are annotated in browser_annotations
             order_value = F(self.order_key)
         else:
             agg_func = _ORDER_AGGREGATE_FUNCS[self.order_key]

codex/views/browser/bookmark.py

@@ -2,9 +2,9 @@
 
 from drf_spectacular.utils import extend_schema
 from rest_framework.response import Response
+from rest_framework.serializers import BaseSerializer
 
-from codex.librarian.bookmark.update import BookmarkUpdate
-from codex.logger.logger import get_logger
+from codex.librarian.bookmark.update import BookmarkUpdateMixin
 from codex.models.comic import Comic
 from codex.serializers.models.bookmark import (
     BookmarkFinishedSerializer,
@@ -13,15 +13,18 @@ from codex.serializers.models.bookmark import (
 from codex.views.bookmark import BookmarkAuthMixin
 from codex.views.browser.filters.filter import BrowserFilterView
 
-LOG = get_logger(__name__)
 
-
-class BookmarkView(BookmarkUpdate, BookmarkAuthMixin, BrowserFilterView):
+class BookmarkView(BookmarkUpdateMixin, BookmarkAuthMixin, BrowserFilterView):
     """User Bookmark View."""
 
-    serializer_class = BookmarkSerializer
+    serializer_class: type[BaseSerializer] | None = BookmarkSerializer
+
+    TARGET: str = "bookmark"
 
-    TARGET = "bookmark"
+    def __init__(self, *args, **kwargs):
+        """Init acl properties."""
+        super().__init__(*args, **kwargs)
+        self.init_group_acl()
 
     def _parse_params(self):
         """Validate and translate the submitted data."""

codex/views/browser/breadcrumbs.py

@@ -3,9 +3,10 @@
 from contextlib import suppress
 from dataclasses import asdict
 from types import MappingProxyType
-from typing import TYPE_CHECKING
+from typing import TYPE_CHECKING, Any
+
+from loguru import logger
 
-from codex.logger.logger import get_logger
 from codex.models import (
     BrowserGroupModel,
     Comic,
@@ -28,7 +29,6 @@ if TYPE_CHECKING:
 
     from codex.models.groups import Folder
 
-LOG = get_logger(__name__)
 _GROUP_INSTANCE_SELECT_RELATED: MappingProxyType[
     type[BrowserGroupModel], tuple[str | None, ...]
 ] = MappingProxyType(
@@ -46,6 +46,7 @@ class BrowserBreadcrumbsView(BrowserPaginateView):
     def __init__(self, *args, **kwargs):
         """Set params for the type checker."""
         super().__init__(*args, **kwargs)
+        # Use 0 to indicate unmemoized because None is a valid value
         self._group_instance: BrowserGroupModel | None | int = 0
 
     def _get_group_query(self, model):
@@ -99,7 +100,7 @@ class BrowserBreadcrumbsView(BrowserPaginateView):
         breadcrumbs: tuple[Mapping[str, str | tuple[int, ...] | int], ...] = tuple(
             self.params.get("breadcrumbs", ())
         )
-        old_breadcrumbs = [Route(**crumb) for crumb in breadcrumbs]
+        old_breadcrumbs = [Route(**crumb) for crumb in breadcrumbs]  # ty: ignore[missing-argument]
         invalid = not old_breadcrumbs or old_breadcrumbs[-1].group not in valid_groups
         if invalid:
             old_breadcrumbs = []
@@ -110,7 +111,7 @@ class BrowserBreadcrumbsView(BrowserPaginateView):
         params = dict(self.params)
         params["breadcrumbs"] = tuple(asdict(crumb) for crumb in breadcrumbs)
         # The only place I rewrite params
-        self._params = MappingProxyType(params)
+        self._params: MappingProxyType[str, Any] | None = MappingProxyType(params)
 
     def _breadcrumbs_graft_or_create_story_arc(self) -> tuple[tuple[Route, ...], bool]:
         """Graft or create story_arc breadcrumbs."""
@@ -152,7 +153,7 @@ class BrowserBreadcrumbsView(BrowserPaginateView):
 
         pks = self.kwargs["pks"]
         page = self.kwargs["page"]
-        folder: Folder | None = self.group_instance  # type: ignore[reportAssignmentType]
+        folder: Folder | None = self.group_instance  # pyright: ignore[reportAssignmentType]
         name = folder.name if folder and pks else ""
         group_crumb = Route(FOLDER_GROUP, pks, page, name)
         new_breadcrumbs = []
@@ -267,7 +268,7 @@ class BrowserBreadcrumbsView(BrowserPaginateView):
                 if done:
                     break
             except Exception:
-                LOG.exception("group loop")
+                logger.exception("group loop")
 
         return tuple(new_breadcrumbs), changed
 

codex/views/browser/browser.py

@@ -6,17 +6,19 @@ from types import MappingProxyType
 from django.db.models import Max
 from django.db.utils import OperationalError
 from drf_spectacular.utils import extend_schema
+from loguru import logger
 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,
     Comic,
     Folder,
     Library,
 )
 from codex.serializers.browser.page import BrowserPageSerializer
-from codex.settings.settings import MAX_OBJ_PER_PAGE
+from codex.settings import MAX_OBJ_PER_PAGE
 from codex.views.browser.title import BrowserTitleView
 from codex.views.const import (
     COMIC_GROUP,
@@ -24,27 +26,24 @@ from codex.views.const import (
     STORY_ARC_GROUP,
 )
 
-LOG = get_logger(__name__)
-
 
 class BrowserView(BrowserTitleView):
     """Browse comics with a variety of filters and sorts."""
 
-    serializer_class = BrowserPageSerializer
+    serializer_class: type[BaseSerializer] | None = BrowserPageSerializer
 
-    ADMIN_FLAG_VALUE_KEY_MAP = MappingProxyType(
-        {
-            AdminFlag.FlagChoices.FOLDER_VIEW.value: "folder_view",
-            AdminFlag.FlagChoices.IMPORT_METADATA.value: "import_metadata",
-        }
+    ADMIN_FLAGS = (
+        AdminFlagChoices.FOLDER_VIEW,
+        AdminFlagChoices.IMPORT_METADATA,
     )
-    TARGET = "browser"
+    TARGET: str = "browser"
 
     ########
     # Init #
     ########
 
     @property
+    @override
     def model_group(self):
         """Get the group of the models to browse."""
         # the model group shown must be:
@@ -144,11 +143,11 @@ class BrowserView(BrowserTitleView):
     def _debug_queries(self, group_count, book_count, group_qs, book_qs):
         """Log query details."""
         if group_count:
-            LOG.debug(group_qs.explain())
-            LOG.debug(group_qs.query)
+            logger.debug(group_qs.explain())
+            logger.debug(group_qs.query)
         if book_count:
-            LOG.debug(book_qs.explain())
-            LOG.debug(book_qs.query)
+            logger.debug(book_qs.explain())
+            logger.debug(book_qs.query)
 
     def _get_group_and_books(self):
         """Create the main queries with filters, annotation and pagination."""
@@ -179,6 +178,7 @@ class BrowserView(BrowserTitleView):
         mtime = self._get_page_mtime()
         return group_qs, book_qs, num_pages, total_page_count, zero_pad, mtime
 
+    @override
     def get_object(self):
         """Validate settings and get the querysets."""
         group_qs, book_qs, num_pages, total_count, zero_pad, mtime = (