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

codex/views/browser/metadata/query_intersections.py

@@ -1,27 +1,19 @@
 """Metadata query fk & m2m intersections."""
 
-from types import MappingProxyType
-
 from django.db.models import Count
+from django.db.models.query import QuerySet
 
-from codex.librarian.importer.const import COMIC_M2M_FIELD_NAMES
+from codex.librarian.scribe.importer.const import COMIC_FK_FIELDS, COMIC_M2M_FIELDS
 from codex.models import Comic
 from codex.models.functions import JsonGroupArray
-from codex.models.groups import Imprint, Publisher, Series, Volume
+from codex.models.groups import Volume
 from codex.views.browser.metadata.annotate import MetadataAnnotateView
-from codex.views.const import METADATA_GROUP_RELATION, MODEL_REL_MAP
-
-_CONTRIBUTOR_RELATIONS = ("role", "person")
-_GROUP_MODELS = MappingProxyType(
-    {
-        "i": (Publisher,),
-        "s": (Publisher, Imprint),
-        "v": (Publisher, Imprint, Series),
-        "c": (Publisher, Imprint, Series, Volume),
-        "f": (Publisher, Imprint, Series, Volume),
-        "a": (Publisher, Imprint, Series, Volume),
-    }
+from codex.views.browser.metadata.const import (
+    COMIC_MAIN_FIELD_NAME_BACK_REL_MAP,
+    GROUP_MODELS,
+    M2M_QUERY_OPTIMIZERS,
 )
+from codex.views.const import METADATA_GROUP_RELATION, MODEL_REL_MAP
 
 
 class MetadataQueryIntersectionsView(MetadataAnnotateView):
@@ -40,32 +32,30 @@ class MetadataQueryIntersectionsView(MetadataAnnotateView):
         pks = self.kwargs["pks"]
         group_filter = {rel: pks}
 
-        for model in _GROUP_MODELS.get(group, ()):
+        for model in GROUP_MODELS.get(group, ()):
             field_name = MODEL_REL_MAP[model]
             qs = model.objects.filter(**group_filter)
-            qs = qs.only("name").distinct()
-            qs = qs.group_by("name")  # type:ignore[reportAttributeAccessIssue]
+            only = ["name"]
+            if model is Volume:
+                only.append("number_to")
+            qs = qs.only(*only).distinct()
+            qs = qs.group_by(*only)  # pyright:ignore[reportAttributeAccessIssue]
             qs = qs.annotate(ids=JsonGroupArray("id", distinct=True))
-            qs = qs.values("ids", "name")
+            qs = qs.values("ids", *only)
             groups[field_name] = qs
         return groups
 
     @staticmethod
-    def _get_optimized_m2m_query(key, qs):
-        if key == "contributors":
-            qs = qs.prefetch_related(*_CONTRIBUTOR_RELATIONS)
-            qs = qs.only(*_CONTRIBUTOR_RELATIONS)
-        elif key == "story_arc_numbers":
-            qs = qs.select_related("story_arc")
-            qs = qs.only("story_arc", "number")
-        elif key == "identifiers":
-            qs = qs.select_related("identifier_type")
-            qs = qs.only("identifier_type", "nss", "url")
-        else:
-            qs = qs.only("name")
-        return qs
-
-    def _get_m2m_intersection_query(self, field_name, comic_pks, comic_pks_count):
+    def _get_optimized_m2m_query(qs):
+        optimizers = M2M_QUERY_OPTIMIZERS.get(qs.model, {})
+        if prefetch := optimizers.get("prefetch"):
+            qs = qs.prefetch_related(*prefetch)
+        if select := optimizers.get("select", ("identifier",)):
+            qs = qs.select_related(*select)
+        only = optimizers.get("only", ("name", "identifier"))
+        return qs.only(*only)
+
+    def _get_m2m_intersection_query(self, field_name: str, comic_pks: frozenset[int]):
         """Get intersection query for one field."""
         model = Comic._meta.get_field(field_name).related_model
         if not model:
@@ -74,29 +64,58 @@ class MetadataQueryIntersectionsView(MetadataAnnotateView):
 
         intersection_qs = model.objects.filter(comic__pk__in=comic_pks)
         intersection_qs = intersection_qs.alias(count=Count("comic")).filter(
-            count=comic_pks_count
+            count=len(comic_pks)
         )
-        return self._get_optimized_m2m_query(field_name, intersection_qs)
+        return self._get_optimized_m2m_query(intersection_qs)
 
-    def _query_m2m_intersections(self, filtered_qs):
-        """Query the through models to figure out m2m intersections."""
-        # Speed ok, but still does a query per m2m model
-        m2m_intersections = {}
+    def _get_comic_pks(self, filtered_qs: QuerySet) -> frozenset[int]:
         pk_field = self.rel_prefix + "pk"
         comic_pks = filtered_qs.distinct().values_list(pk_field, flat=True)
         # In fts mode the join doesn't work for the query.
         # Evaluating it now is probably faster than running the filter for every m2m anyway.
-        comic_pks = set(comic_pks)
-        comic_pks_count = len(comic_pks)
+        return frozenset(comic_pks)
+
+    def _query_m2m_intersections(self, comic_pks: frozenset[int]):
+        """Query the through models to figure out m2m intersections."""
+        # Speed ok, but still does a query per m2m model
+        m2m_intersections = {}
 
-        for field_name in COMIC_M2M_FIELD_NAMES:
-            m2m_intersections[field_name] = self._get_m2m_intersection_query(
-                field_name, comic_pks, comic_pks_count
+        for field in COMIC_M2M_FIELDS:
+            m2m_intersections[field.name] = self._get_m2m_intersection_query(
+                field.name, comic_pks
             )
         return m2m_intersections
 
+    def _get_fk_intersection_query(
+        self, field_name: str, comic_pks: frozenset[int], rel: str
+    ):
+        """Get intersection query for one field."""
+        model = Comic._meta.get_field(field_name).related_model
+        if not model:
+            reason = f"No model found for comic field: {field_name}"
+            raise ValueError(reason)
+
+        rel += "__in"
+        intersection_qs = model.objects.filter(**{rel: comic_pks})
+        intersection_qs = intersection_qs.alias(count=Count("comic")).filter(
+            count=len(comic_pks)
+        )
+        return intersection_qs.only("name")
+
+    def _query_fk_intersections(self, comic_pks: frozenset[int]):
+        fk_intersections = {}
+
+        for field in COMIC_FK_FIELDS:
+            rel = COMIC_MAIN_FIELD_NAME_BACK_REL_MAP.get(field.name, "comic__pk")
+            fk_intersections[field.name] = self._get_fk_intersection_query(
+                field.name, comic_pks, rel
+            )
+        return fk_intersections
+
     def query_intersections(self, filtered_qs):
         """Query complex intersections."""
         groups = self._query_groups()
-        m2m_intersections = self._query_m2m_intersections(filtered_qs)
-        return groups, m2m_intersections
+        comic_pks = self._get_comic_pks(filtered_qs)
+        fk_intersections = self._query_fk_intersections(comic_pks)
+        m2m_intersections = self._query_m2m_intersections(comic_pks)
+        return groups, fk_intersections, m2m_intersections

codex/views/browser/mtime.py

@@ -2,25 +2,22 @@
 
 from drf_spectacular.utils import extend_schema
 from rest_framework.response import Response
+from rest_framework.serializers import BaseSerializer
 
-from codex.logger.logger import get_logger
 from codex.models.groups import Publisher
 from codex.serializers.browser.mtime import GroupsMtimeSerializer, MtimeSerializer
 from codex.util import max_none
 from codex.views.browser.group_mtime import BrowserGroupMtimeView
 from codex.views.const import GROUP_MODEL_MAP
 
-LOG = get_logger(__name__)
-
 
 class MtimeView(BrowserGroupMtimeView):
     """Get the mtimes for the submitted groups."""
 
-    input_serializer_class = GroupsMtimeSerializer
-    serializer_class = MtimeSerializer
+    input_serializer_class: type[GroupsMtimeSerializer] = GroupsMtimeSerializer  # pyright: ignore[reportIncompatibleVariableOverride]
+    serializer_class: type[BaseSerializer] | None = MtimeSerializer
 
-    REPARSE_JSON_FIELDS = frozenset({"groups", "filters"})
-    TARGET = "mtime"
+    TARGET: str = "mtime"
 
     def _get_group_mtime(self, item):
         """Get one group's mtimes."""

codex/views/browser/order_by.py

@@ -1,6 +1,7 @@
 """Base view for ordering the query."""
 
 from codex.models import Comic
+from codex.models.groups import Volume
 from codex.views.browser.group_mtime import BrowserGroupMtimeView
 
 
@@ -39,6 +40,7 @@ class BrowserOrderByView(BrowserGroupMtimeView):
                 *comic_sort_names,
                 "issue_number",
                 "issue_suffix",
+                "collection_title",
                 "sort_name",
             ]
         else:
@@ -55,9 +57,10 @@ class BrowserOrderByView(BrowserGroupMtimeView):
 
     def add_order_by(self, qs, order_key="", comic_sort_names=None):
         """Create the order_by list."""
-        order_fields_head = ()
         if qs.model is Comic:
             order_fields_head = self._add_comic_order_by(order_key, comic_sort_names)
+        elif qs.model is Volume and order_key == "sort_name":
+            order_fields_head = ["name", "number_to"]
         else:
             order_fields_head = ["order_value"]
 

codex/views/browser/page_in_bounds.py

@@ -1,18 +1,17 @@
 """Browser Page Bounds Checking."""
 
-from codex.logger.logger import get_logger
+from loguru import logger
+
 from codex.views.browser.annotate.card import BrowserAnnotateCardView
 from codex.views.util import Route
 
-LOG = get_logger(__name__)
-
 
 class BrowserPageInBoundsView(BrowserAnnotateCardView):
     """Browser Page Bounds Checking."""
 
     def _get_back_one_page_route(self, num_pages):
         """Get max page if oob or 1."""
-        LOG.debug("Redirect back one page.")
+        logger.debug("Redirect back one page.")
         group = self.kwargs.get("group")
         pks = self.kwargs.get("pks")
         page = self.kwargs.get("page", 1)
@@ -49,14 +48,14 @@ class BrowserPageInBoundsView(BrowserAnnotateCardView):
             up_breadcrumbs = self._get_up_breadcrumbs()
             route_mask = up_breadcrumbs[-1]
             settings_mask = {"breadcrumbs": up_breadcrumbs}
-            LOG.debug("Redirect up a level.")
+            logger.debug("Redirect up a level.")
         except IndexError:
             group = self.kwargs.get("group")
             pks = "0"
             new_page = 1
             route_mask = {"group": group, "pks": pks, "page": new_page}
             settings_mask = {"breadcrumbs": [route_mask]}
-            LOG.debug("Redirect to all at current group.")
+            logger.debug("Redirect to all at current group.")
         return route_mask, settings_mask
 
     def _handle_page_out_of_bounds(self, num_pages):

codex/views/browser/paginate.py

@@ -3,13 +3,11 @@
 from math import ceil
 
 from django.core.paginator import EmptyPage, Paginator
+from loguru import logger
 
-from codex.logger.logger import get_logger
-from codex.settings.settings import MAX_OBJ_PER_PAGE
+from codex.settings import MAX_OBJ_PER_PAGE
 from codex.views.browser.page_in_bounds import BrowserPageInBoundsView
 
-LOG = get_logger(__name__)
-
 
 class BrowserPaginateView(BrowserPageInBoundsView):
     """Paginate Groups and Books."""
@@ -24,7 +22,7 @@ class BrowserPaginateView(BrowserPageInBoundsView):
         except EmptyPage:
             if self.model_group != "f":
                 model_name = qs.model.__name__ if qs.model else "UnknownGroup"
-                LOG.warning(f"No {model_name}s on page {page}")
+                logger.warning(f"No {model_name}s on page {page}")
             qs = qs.model.objects.none()
 
         return qs

codex/views/browser/params.py

@@ -6,39 +6,23 @@ from typing import Any
 from codex.serializers.browser.settings import BrowserSettingsSerializer
 from codex.views.const import FOLDER_GROUP, STORY_ARC_GROUP
 from codex.views.session import SessionView
-from codex.views.util import reparse_json_query_params
 
 
 class BrowserParamsView(SessionView):
     """Browser Params Parsing."""
 
-    input_serializer_class = BrowserSettingsSerializer
-    REPARSE_JSON_FIELDS = frozenset({"breadcrumbs", "filters", "show"})
+    input_serializer_class: type[BrowserSettingsSerializer] = BrowserSettingsSerializer
 
     def __init__(self, *args, **kwargs):
         """Initialize properties."""
         super().__init__(*args, **kwargs)
         self._params: MappingProxyType[str, Any] | None = None
 
-    def _parse_query_params(self):
-        """Parse GET query parameters: filter object & snake case."""
-        query_params = reparse_json_query_params(
-            self.request.GET, self.REPARSE_JSON_FIELDS
-        )
-        if "q" not in query_params and (query := query_params.get("query")):
-            # parse query param for opds v2
-            query_params["q"] = query
-        return query_params
-
-    def validate_settings(self):
-        """Not used until browser/validate.py."""
-
     @property
     def params(self):
-        """Validate sbmitted settings and apply them over the session settings."""
+        """Validate submitted settings and apply them over the session settings."""
         if self._params is None:
-            data = self._parse_query_params()
-            serializer = self.input_serializer_class(data=data)
+            serializer = self.input_serializer_class(data=self.request.GET)
             serializer.is_valid(raise_exception=True)
 
             params: dict[str, Any] = {}
@@ -60,5 +44,4 @@ class BrowserParamsView(SessionView):
             if validated_data:
                 params.update(validated_data)
             self._params = MappingProxyType(params)
-            self.validate_settings()
         return self._params

codex/views/browser/settings.py

@@ -1,6 +1,13 @@
 """Browser session view."""
 
-from codex.serializers.browser.settings import BrowserSettingsSerializer
+from drf_spectacular.utils import extend_schema
+from rest_framework.serializers import BaseSerializer
+from typing_extensions import override
+
+from codex.serializers.browser.settings import (
+    BrowserSettingsInputSerializer,
+    BrowserSettingsSerializer,
+)
 from codex.views.const import GROUP_ORDER
 from codex.views.settings import SettingsView
 
@@ -8,10 +15,11 @@ from codex.views.settings import SettingsView
 class BrowserSettingsView(SettingsView):
     """Get Browser Settings."""
 
+    input_serializer_class = BrowserSettingsInputSerializer
     # Put Browser Settings is normally done through BrowserView.get()
-    serializer_class = BrowserSettingsSerializer
+    serializer_class: type[BaseSerializer] | None = BrowserSettingsSerializer
 
-    SESSION_KEY = SettingsView.BROWSER_SESSION_KEY
+    SESSION_KEY: str = SettingsView.BROWSER_SESSION_KEY
 
     @staticmethod
     def _strip_breadcrumb_names(params):
@@ -49,11 +57,12 @@ class BrowserSettingsView(SettingsView):
         if group == top_group:
             return
 
-        if group in ("f", "a"):
+        if group in "fa":
             params["top_group"] = group
         else:
             cls._validate_browse_top_group(params, group, top_group)
 
+    @override
     def validate_settings_get(self, validated_data, params):
         """Change bad settings."""
         top_group = params["top_group"]
@@ -64,3 +73,8 @@ class BrowserSettingsView(SettingsView):
             params = self._strip_breadcrumb_names(params)
 
         return params
+
+    @override
+    @extend_schema(parameters=[BrowserSettingsInputSerializer])
+    def get(self, *args, **kwargs):
+        return super().get(*args, **kwargs)

codex/views/browser/title.py

@@ -18,26 +18,30 @@ class BrowserTitleView(BrowserBreadcrumbsView):
         return plural.capitalize(), 0
 
     def _get_group_name(self):
+        group_number_to = None
         group_count = 0
+        group_name = ""
         if gi := self.group_instance:
+            group_name = gi.name
             if isinstance(gi, Volume):
+                group_number_to = gi.number_to
                 group_count = gi.series.volume_count
             elif isinstance(gi, Comic):
+                group_number_to = gi.volume.number_to
                 group_count = gi.volume.issue_count
-            group_name = gi.name
-        else:
-            group_name = ""
-        return group_name, group_count
+        return group_name, group_number_to, group_count
 
     def get_browser_page_title(self):
         """Get the proper title for this browse level."""
         pks = self.kwargs.get("pks")
         if not pks:
             group_name, group_count = self._get_root_group_name()
+            group_number_to = None
         else:
-            group_name, group_count = self._get_group_name()
+            group_name, group_number_to, group_count = self._get_group_name()
 
         return {
             "group_name": group_name,
+            "group_number_to": group_number_to,
             "group_count": group_count,
         }

codex/views/browser/validate.py

@@ -5,11 +5,10 @@ from copy import deepcopy
 from types import MappingProxyType
 from typing import Any
 
+from loguru import logger
 from rest_framework.exceptions import NotFound
 
 from codex.choices.browser import DEFAULT_BROWSER_ROUTE
-from codex.exceptions import SeeOtherRedirectError
-from codex.logger.logger import get_logger
 from codex.models.groups import BrowserGroupModel
 from codex.util import mapping_to_dict
 from codex.views.browser.filters.search.parse import SearchFilterView
@@ -20,8 +19,7 @@ from codex.views.const import (
     ROOT_GROUP,
     STORY_ARC_GROUP,
 )
-
-LOG = get_logger(__name__)
+from codex.views.exceptions import SeeOtherRedirectError
 
 
 class BrowserValidateView(SearchFilterView):
@@ -58,7 +56,7 @@ class BrowserValidateView(SearchFilterView):
             if model is None:
                 group = self.kwargs["group"]
                 detail = f"Cannot browse {group=}"
-                LOG.debug(detail)
+                logger.debug(detail)
                 raise NotFound(detail=detail)
             self._model = model
         return self._model
@@ -74,10 +72,10 @@ class BrowserValidateView(SearchFilterView):
         self, reason, route_mask=None, settings_mask: Mapping | None = None
     ):
         """Redirect the client to a valid group url."""
-        route: dict[str, Any] = mapping_to_dict(self.DEFAULT_ROUTE)  # type:ignore[reportAssignmentType]
+        route: dict[str, Any] = mapping_to_dict(self.DEFAULT_ROUTE)
         if route_mask:
             route["params"].update(route_mask)
-        settings: dict[str, Any] = deepcopy(mapping_to_dict(self.params))  # type: ignore[reportAssignmentType]
+        settings: dict[str, Any] = deepcopy(mapping_to_dict(self.params))
         if settings_mask:
             settings.update(settings_mask)
         detail = {"route": route, "settings": settings, "reason": reason}
@@ -104,7 +102,7 @@ class BrowserValidateView(SearchFilterView):
         nav_group = self.kwargs.get("group")
         top_group = self.params.get("top_group")
         if top_group not in valid_top_groups:
-            reason = f"top_group {top_group} not in valid nav groups, changed to "
+            reason = f"top_group {top_group} not in valid nav groups {valid_top_groups}, changed to "
             if nav_group in valid_top_groups:
                 valid_top_group = nav_group
                 reason += "nav group: "

codex/views/const.py

@@ -13,14 +13,14 @@ from codex.models import (
     BrowserGroupModel,
     Character,
     Comic,
-    Contributor,
-    ContributorPerson,
-    ContributorRole,
     Country,
+    Credit,
+    CreditPerson,
+    CreditRole,
     Folder,
     Genre,
     Identifier,
-    IdentifierType,
+    IdentifierSource,
     Imprint,
     Language,
     Library,
@@ -35,9 +35,10 @@ from codex.models import (
     Tag,
     Tagger,
     Team,
+    Universe,
     Volume,
 )
-from codex.settings.settings import CODEX_PATH
+from codex.settings import CODEX_PATH
 
 ROOT_GROUP = "r"
 FOLDER_GROUP = "f"
@@ -124,9 +125,12 @@ METADATA_MODELS = (
     AgeRating,
     Character,
     Country,
+    Credit,
+    CreditPerson,
+    CreditRole,
     Genre,
     Identifier,
-    IdentifierType,
+    IdentifierSource,
     Language,
     Location,
     OriginalFormat,
@@ -137,9 +141,7 @@ METADATA_MODELS = (
     Team,
     Tag,
     Tagger,
-    Contributor,
-    ContributorPerson,
-    ContributorRole,
+    Universe,
 )
 CONFIG_MODELS = (
     Library,

codex/views/download.py

@@ -15,7 +15,7 @@ class DownloadView(AuthFilterAPIView):
 
     content_type = "application/vnd.comicbook+zip"
 
-    AS_ATTACHMENT = True
+    AS_ATTACHMENT: bool = True
 
     @extend_schema(responses={(200, content_type): OpenApiTypes.BINARY})
     def get(self, *_args, **kwargs):
@@ -55,4 +55,4 @@ class DownloadView(AuthFilterAPIView):
 class FileView(DownloadView):
     """View a single comic in the browser."""
 
-    AS_ATTACHMENT = False
+    AS_ATTACHMENT: bool = False

codex/views/error.py

@@ -5,7 +5,7 @@ from django.urls import reverse
 from rest_framework import status
 from rest_framework.views import exception_handler
 
-from codex.exceptions import SeeOtherRedirectError
+from codex.views.exceptions import SeeOtherRedirectError
 
 _OPDS_PREFIX = "opds/v"
 

codex/views/exceptions.py

@@ -0,0 +1,82 @@
+"""Special Redirect Error."""
+
+from collections.abc import Mapping
+from copy import deepcopy
+from pprint import pformat
+
+from django.core.validators import EMPTY_VALUES
+from django.shortcuts import redirect
+from django.urls import reverse
+from loguru import logger
+from rest_framework.exceptions import APIException
+from rest_framework.status import HTTP_303_SEE_OTHER
+
+from codex.choices.browser import DEFAULT_BROWSER_ROUTE
+from codex.serializers.fields.browser import BreadcrumbsField
+from codex.serializers.route import RouteSerializer
+from codex.views.util import pop_name
+
+_OPDS_REDIRECT_SETTINGS_KEYS = ("order_by", "top_group")
+_REDIRECT_SETTINGS_KEYS = ("breadcrumbs", *_OPDS_REDIRECT_SETTINGS_KEYS)
+
+
+class SeeOtherRedirectError(APIException):
+    """Redirect for 303."""
+
+    status_code = HTTP_303_SEE_OTHER
+    default_code = "redirect"
+    default_detail = "redirect to a valid route"
+
+    def __init__(self, detail):
+        """Create a response to pass to the exception handler."""
+        super().__init__(detail)
+        # Copy to edit and not write over refs
+        detail = dict(detail)
+
+        # Get route params
+        route = detail.get("route", {})
+        params = route.get("params", DEFAULT_BROWSER_ROUTE)
+        params = pop_name(params)
+        route = deepcopy(route)
+        route["params"] = params
+
+        # For OPDS
+        self.route_kwargs = params
+
+        serializer = RouteSerializer(params)
+        route["params"] = serializer.data
+        detail["route"] = route
+
+        filtered_settings = {}
+        settings = detail.get("settings", {})
+        for key in _REDIRECT_SETTINGS_KEYS:
+            value = settings.get(key)
+            if value in EMPTY_VALUES:
+                continue
+            if key == "breadcrumbs":
+                value = BreadcrumbsField().to_representation(value)
+            filtered_settings[key] = value
+        detail["settings"] = filtered_settings
+
+        self.detail = detail
+
+        logger.debug(f"redirect {pformat(self.detail)}")
+
+    def _get_query_params(self):
+        """Change OPDS settings like the frontend does with error.detail."""
+        query_params = {}
+        settings = (
+            self.detail.get("settings", {}) if isinstance(self.detail, Mapping) else {}
+        )
+        for key in _OPDS_REDIRECT_SETTINGS_KEYS:
+            value = settings.get(key)
+            if value not in EMPTY_VALUES:
+                query_params[key] = value
+        return query_params
+
+    def get_response(self, url_name):
+        """Return a Django Redirect Response."""
+        # only used in codex_exception_handler for opds stuff
+        query = self._get_query_params()
+        url = reverse(url_name, kwargs=self.route_kwargs, query=query)
+        return redirect(url, permanent=False)