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

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)

codex/views/frontend.py

@@ -1,24 +1,23 @@
 """Frontend views."""
 
-from typing import ClassVar
+from collections.abc import Sequence
 
-from rest_framework.permissions import AllowAny
-from rest_framework.renderers import TemplateHTMLRenderer
+from rest_framework.permissions import AllowAny, BasePermission
+from rest_framework.renderers import BaseRenderer, TemplateHTMLRenderer
 from rest_framework.response import Response
 
-from codex.models.admin import AdminFlag
 from codex.serializers.route import RouteSerializer
-from codex.views.mixins import UserActiveViewMixin
+from codex.views.mixins import UserActiveMixin
 from codex.views.session import SessionView
 
 
-class IndexView(SessionView, UserActiveViewMixin):
+class IndexView(SessionView, UserActiveMixin):
     """The main app."""
 
-    SESSION_KEY = SessionView.BROWSER_SESSION_KEY
+    SESSION_KEY: str = SessionView.BROWSER_SESSION_KEY
 
-    permission_classes = (AllowAny,)
-    renderer_classes: ClassVar[list] = [TemplateHTMLRenderer]  # type: ignore[reportIncompatibleVariableOverride]
+    permission_classes: Sequence[type[BasePermission]] = (AllowAny,)
+    renderer_classes: Sequence[type[BaseRenderer]] = [TemplateHTMLRenderer]
     template_name = "index.html"
 
     def _get_last_route(self):
@@ -27,19 +26,10 @@ class IndexView(SessionView, UserActiveViewMixin):
         serializer = RouteSerializer(last_route)
         return serializer.data
 
-    def _get_title(self):
-        """Get the title from the banner text."""
-        bt_flag = AdminFlag.objects.get(key="BT")
-        title = "Codex"
-        if bt_flag.value:
-            title = bt_flag.value + " - " + title
-        return title
-
     def get(self, *_args, **_kwargs):
         """Get the app index page."""
         extra_context = {
             "last_route": self._get_last_route(),
-            "title": self._get_title(),
         }
         self.mark_user_active()
         return Response(extra_context)

codex/views/lazy_import.py

@@ -0,0 +1,24 @@
+"""Version View."""
+
+from rest_framework.response import Response
+
+from codex.librarian.mp_queue import LIBRARIAN_QUEUE
+from codex.librarian.scribe.tasks import LazyImportComicsTask
+from codex.serializers.mixins import OKSerializer
+from codex.views.auth import AuthGenericAPIView
+
+
+class LazyImportView(AuthGenericAPIView):
+    """Return Codex Versions."""
+
+    serializer_class = OKSerializer
+
+    def get(self, *args, **kwargs):
+        """Get Versions."""
+        group = self.kwargs.get("group", "")
+        if group in "fc":
+            pks = self.kwargs.get("pks", ())
+            pks = frozenset(pks)
+            LIBRARIAN_QUEUE.put(LazyImportComicsTask(group=group, pks=pks))
+        serializer = self.get_serializer()
+        return Response(serializer.data)

codex/views/mixins.py

@@ -1,22 +1,26 @@
 """Cross view annotation methods."""
 
-from django.db.models.expressions import F
-from rest_framework.views import APIView
+from typing import TYPE_CHECKING
+
+from django.db.models import CharField
+from django.db.models.expressions import Case, F, Value, When
+from django.db.models.functions import Concat
 
 from codex.librarian.bookmark.tasks import UserActiveTask
 from codex.librarian.mp_queue import LIBRARIAN_QUEUE
-from codex.logger.logger import get_logger
-from codex.models.comic import Comic, Imprint, Volume
-from codex.views.browser.filters.filter import BrowserFilterView
+from codex.models.comic import Comic
+from codex.models.groups import Imprint, Volume
 from codex.views.const import GROUP_NAME_MAP
 
-LOG = get_logger(__name__)
+if TYPE_CHECKING:
+    from rest_framework.request import Request
+
 _SHOW_GROUPS = tuple(GROUP_NAME_MAP.keys())
 _GROUP_NAME_TARGETS = frozenset({"browser", "opds1", "opds2", "reader"})
 _VARIABLE_SHOW = "pi"
 
 
-class SharedAnnotationsMixin(BrowserFilterView):
+class SharedAnnotationsMixin:  # (BrowserFilterView):
     """Cross view annotation methods."""
 
     @staticmethod
@@ -54,14 +58,32 @@ class SharedAnnotationsMixin(BrowserFilterView):
             sort_name_annotations["sort_name"] = F("name")
         return sort_name_annotations
 
+    @staticmethod
+    def _volume_name_annotation(model):
+        prefix = "volume__" if model is Comic else ""
+        name_rel = prefix + "name"
+        number_to_rel = prefix + "number_to"
+
+        return Case(
+            When(**{f"{number_to_rel}__isnull": True}, then=F(name_rel)),
+            default=Concat(
+                F(name_rel),
+                Value("-"),
+                F(number_to_rel),
+            ),
+            output_field=CharField(),
+        )
+
     @classmethod
     def annotate_group_names(cls, qs):
         """Annotate name fields by hoisting them up."""
         # Optimized to only lookup what is used on the frontend
-        target = cls.TARGET
+        target = cls.TARGET  #  pyright: ignore[reportAttributeAccessIssue]
         if target not in _GROUP_NAME_TARGETS:
             return qs
         group_names = {}
+        if qs.model in (Comic, Volume):
+            group_names["series_name"] = F("series__name")
         if qs.model is Comic:
             if target != "reader":
                 group_names["publisher_name"] = F("publisher__name")
@@ -69,22 +91,22 @@ class SharedAnnotationsMixin(BrowserFilterView):
                     group_names["imprint_name"] = F("imprint__name")
             group_names.update(
                 {
-                    "series_name": F("series__name"),
                     "volume_name": F("volume__name"),
+                    "volume_number_to": F("volume__number_to"),
                 }
             )
-        elif qs.model is Volume:
-            group_names["series_name"] = F("series__name")
         elif qs.model is Imprint:
             group_names["publisher_name"] = F("publisher__name")
         return qs.annotate(**group_names)
 
 
-class UserActiveViewMixin(APIView):
+class UserActiveMixin:
     """View that records user activity."""
 
     def mark_user_active(self):
         """Get the app index page."""
+        if TYPE_CHECKING:
+            self.request: Request  # pyright: ignore[reportUninitializedInstanceVariable]
         if self.request.user and self.request.user.pk:
             task = UserActiveTask(pk=self.request.user.pk)
             LIBRARIAN_QUEUE.put(task)

codex/views/opds/auth.py

@@ -3,7 +3,7 @@
 from rest_framework.authentication import BasicAuthentication, SessionAuthentication
 
 from codex.views.auth import IsAuthenticatedOrEnabledNonUsers
-from codex.views.template import CodexXMLTemplateView
+from codex.views.template import CodexXMLTemplateMixin
 
 
 class OPDSAuthMixin:
@@ -13,5 +13,5 @@ class OPDSAuthMixin:
     permission_classes = (IsAuthenticatedOrEnabledNonUsers,)
 
 
-class OPDSTemplateView(OPDSAuthMixin, CodexXMLTemplateView):
+class OPDSTemplateMixin(OPDSAuthMixin, CodexXMLTemplateMixin):
     """XML Template view with OPDSAuth."""

codex/views/opds/authentication_v1.py

@@ -6,6 +6,7 @@ from django.contrib.staticfiles.storage import staticfiles_storage
 from django.urls import reverse_lazy
 from rest_framework.generics import GenericAPIView
 from rest_framework.response import Response
+from rest_framework.serializers import BaseSerializer
 
 from codex.serializers.opds.authentication import OPDSAuthentication1Serializer
 
@@ -58,7 +59,7 @@ _DOC = MappingProxyType(
 class OPDSAuthentication1View(GenericAPIView):
     """Authentication document."""
 
-    serializer_class = OPDSAuthentication1Serializer
+    serializer_class: type[BaseSerializer] | None = OPDSAuthentication1Serializer
 
     def get(self, *args, **kwargs):
         """Fill in the authentication dict."""

codex/views/opds/const.py

@@ -13,7 +13,7 @@ from codex.models import (
 )
 
 BLANK_TITLE = "Unknown"
-AUTHOR_ROLES = {"Writer"}
+AUTHOR_ROLES = {"Writer", "Author", "Script", "Plot", "Plotter", "Scripter"}
 
 
 class Rel:

codex/views/opds/urls.py

@@ -2,6 +2,7 @@
 
 from django.urls import reverse
 from rest_framework.response import Response
+from rest_framework.serializers import BaseSerializer
 
 from codex.choices.browser import DEFAULT_BROWSER_ROUTE
 from codex.serializers.opds.urls import OPDSURLsSerializer
@@ -14,7 +15,7 @@ _OPDS_VERSIONS = (1, 2)
 class OPDSURLsView(AuthGenericAPIView):
     """OPDS URLs."""
 
-    serializer_class = OPDSURLsSerializer
+    serializer_class: type[BaseSerializer] | None = OPDSURLsSerializer
 
     def get(self, *args, **kwargs):
         """Resolve the urls."""

codex/views/opds/util.py

@@ -3,54 +3,36 @@
 from django.db.models import F
 from django.http.response import HttpResponseRedirect
 from django.urls import reverse
-from django.utils.http import urlencode
 
 from codex.choices.browser import DEFAULT_BROWSER_ROUTE
 from codex.models import (
-    Contributor,
-    ContributorPerson,
+    Credit,
+    CreditPerson,
 )
 from codex.views.auth import GroupACLMixin
 from codex.views.opds.const import OPDS_M2M_MODELS
 
 
-def update_href_query_params(href, old_query_params, new_query_params=None):
-    """Update an href by masking query params on top of the ones it has."""
-    query_params = {}
-    for key, value in old_query_params.items():
-        # qps are sometimes encapsulated in a list for when there's multiples.
-        if isinstance(value, list):
-            if len(value):
-                query_params[key] = value[0]
-        else:
-            query_params[key] = value
-    if new_query_params:
-        query_params.update(new_query_params)
-    if query_params:
-        href += "?" + urlencode(query_params, doseq=True)
-    return href
-
-
-def get_contributor_people(comic_pks, roles, exclude):
-    """Get contributors that are not authors."""
-    people = ContributorPerson.objects.filter(
-        contributor__comic__in=comic_pks,
+def get_credit_people(comic_pks, roles, exclude):
+    """Get credits that are not authors."""
+    people = CreditPerson.objects.filter(
+        credit__comic__in=comic_pks,
     )
     if exclude:
-        people = people.exclude(contributor__role__name__in=roles)
+        people = people.exclude(credit__role__name__in=roles)
     else:
-        people = people.filter(contributor__role__name__in=roles)
+        people = people.filter(credit__role__name__in=roles)
     return people.distinct().only("name")
 
 
-def get_contributors(comic_pks, roles, exclude):
+def get_credits(comic_pks, roles, exclude):
     """Get credits that are not part of other roles."""
-    contributors = Contributor.objects.filter(comic__in=comic_pks)
+    credit_qs = Credit.objects.filter(comic__in=comic_pks)
     if exclude:
-        contributors = contributors.exclude(role__name__in=roles)
+        credit_qs = credit_qs.exclude(role__name__in=roles)
     else:
-        contributors = contributors.filter(role__name__in=roles)
-    return contributors.annotate(name=F("person__name"), role_name=F("role__name"))
+        credit_qs = credit_qs.filter(role__name__in=roles)
+    return credit_qs.annotate(name=F("person__name"), role_name=F("role__name"))
 
 
 def get_m2m_objects(pks) -> dict:
@@ -72,16 +54,7 @@ def full_redirect_view(url_name):
     def func(request):
         """Redirect to view, forwarding query strings and auth."""
         kwargs = dict(DEFAULT_BROWSER_ROUTE)
-        url = reverse(url_name, kwargs=kwargs)
-
-        # Forward the query string.
-        path = request.get_full_path()
-        if path:
-            parts = path.split("?")
-            if len(parts) >= 2:  # noqa: PLR2004
-                parts[0] = url
-                url = "?".join(parts)
-
+        url = reverse(url_name, kwargs=kwargs, query=request.GET)
         response = HttpResponseRedirect(url)
 
         # Forward authorization.

codex/views/opds/v1/entry/entry.py

@@ -3,24 +3,23 @@
 import json
 from contextlib import suppress
 from datetime import datetime, timezone
-from urllib.parse import urlencode
 
 from dateutil import parser
 from django.urls import reverse
+from loguru import logger
 
-from codex.logger.logger import get_logger
 from codex.models import Comic
 from codex.views.opds.const import (
     AUTHOR_ROLES,
     BLANK_TITLE,
 )
 from codex.views.opds.util import (
-    get_contributor_people,
+    get_credit_people,
     get_m2m_objects,
 )
 from codex.views.opds.v1.entry.links import OPDS1EntryLinksMixin
 
-LOG = get_logger(__name__)
+_SERIES_ROUTE_KWARGS = {"group": "s", "pks": {}, "page": 1}
 
 
 class OPDS1Entry(OPDS1EntryLinksMixin):
@@ -59,7 +58,7 @@ class OPDS1Entry(OPDS1EntryLinksMixin):
 
             result = " ".join(filter(None, parts))
         except Exception:
-            LOG.exception("Getting OPDS1 title")
+            logger.exception("Getting OPDS1 title")
 
         if not result:
             result = BLANK_TITLE
@@ -120,13 +119,11 @@ class OPDS1Entry(OPDS1EntryLinksMixin):
     @staticmethod
     def _add_url_to_obj(objs, filter_key):
         """Add filter urls to objects."""
-        kwargs = {"group": "s", "pks": {}, "page": 1}
-        url_base = reverse("opds:v1:feed", kwargs=kwargs)
         result = []
         for obj in objs:
-            qp = {"filters": json.dumps({filter_key: [obj.pk]})}
-            qp = urlencode(qp)
-            obj.url = url_base + "?" + qp
+            filters = json.dumps({filter_key: [obj.pk]})
+            query = {"filters": filters}
+            obj.url = reverse("opds:v1:feed", kwargs=_SERIES_ROUTE_KWARGS, query=query)
             result.append(obj)
         return result
 
@@ -135,16 +132,16 @@ class OPDS1Entry(OPDS1EntryLinksMixin):
         """Get Author names."""
         if not self.metadata:
             return []
-        people = get_contributor_people(self.obj.ids, AUTHOR_ROLES, exclude=False)
-        return self._add_url_to_obj(people, "contributors")
+        people = get_credit_people(self.obj.ids, AUTHOR_ROLES, exclude=False)
+        return self._add_url_to_obj(people, "credits")
 
     @property
     def contributors(self):
-        """Get Contributor names."""
+        """Get Credit names."""
         if not self.metadata:
             return []
-        people = get_contributor_people(self.obj.ids, AUTHOR_ROLES, exclude=True)
-        return self._add_url_to_obj(people, "contributors")
+        people = get_credit_people(self.obj.ids, AUTHOR_ROLES, exclude=True)
+        return self._add_url_to_obj(people, "credits")
 
     @property
     def category_groups(self):

codex/views/opds/v1/entry/links.py

@@ -6,21 +6,19 @@ from urllib.parse import quote_plus
 
 from comicbox.box import Comicbox
 from django.urls import reverse
+from loguru import logger
 
-from codex.logger.logger import get_logger
+from codex.settings import COMICBOX_CONFIG
 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
 
-LOG = get_logger(__name__)
-
 
 class OPDS1EntryLinksMixin:
     """OPDS v1 Entry Links Methods."""
 
     def __init__(
-        self, obj, query_params, data: OPDS1EntryData, title_filename_fallback: bool
+        self, obj, query_params, data: OPDS1EntryData, *, title_filename_fallback: bool
     ):
         """Initialize params."""
         self.obj = obj
@@ -43,18 +41,17 @@ class OPDS1EntryLinksMixin:
                 "dynamicCovers": False,
                 "ts": ts,
             }
-            href = reverse("opds:bin:cover", kwargs=kwargs)
-            href = update_href_query_params(href, query_params)
+            href = reverse("opds:bin:cover", kwargs=kwargs, query=query_params)
             return OPDS1Link(rel, href, MimeType.WEBP)
         except Exception:
-            LOG.exception("create thumb")
+            logger.exception("create thumb")
 
-    def _nav_href(self, metadata: bool):
+    def _nav_href(self, *, metadata: bool):
         try:
             pks = sorted(self.obj.ids)
             kwargs = {"group": self.obj.group, "pks": pks, "page": 1}
-            href = reverse("opds:v1:feed", kwargs=kwargs)
             qps = {}
+            qps.update(self.query_params)
             if (
                 self.obj.group == "a"
                 and self.obj.ids
@@ -65,14 +62,14 @@ class OPDS1EntryLinksMixin:
                 qps.update({"orderBy": "story_arc_number"})
             if metadata:
                 qps.update({"opdsMetadata": 1})
-            return update_href_query_params(href, self.query_params, qps)
+            return reverse("opds:v1:feed", kwargs=kwargs, query=qps)
         except Exception:
             msg = f"creating nav href for entry {self.obj}"
-            LOG.exception(msg)
+            logger.exception(msg)
             raise
 
-    def _nav_link(self, metadata: bool):
-        href = self._nav_href(metadata)
+    def _nav_link(self, *, metadata: bool):
+        href = self._nav_href(metadata=metadata)
 
         group = self.obj.group
         if group in self.acquision_groups:
@@ -101,10 +98,10 @@ class OPDS1EntryLinksMixin:
         """Get barebones metadata lazily to make pse work for chunky-like readers."""
         if self.obj.page_count and self.obj.file_type:
             return False
-        with Comicbox(self.obj.path) as cb:
+        with Comicbox(self.obj.path, config=COMICBOX_CONFIG, logger=logger) as cb:
             self.obj.page_count = cb.get_page_count()
             self.obj.file_type = cb.get_file_type()
-        LOG.debug(f"Got lazy opds pse metadata for {self.obj.path}")
+        logger.debug(f"Got lazy opds pse metadata for {self.obj.path}")
         return True
 
     def _stream_link(self):
@@ -113,8 +110,7 @@ class OPDS1EntryLinksMixin:
             return None
         kwargs = {"pk": pk, "page": 0}
         qps = {"bookmark": 1}
-        href = reverse("opds:bin:page", kwargs=kwargs)
-        href = update_href_query_params(href, {}, qps)
+        href = reverse("opds:bin:page", kwargs=kwargs, query=qps)
         href = href.replace("0/page.jpg", "{pageNumber}/page.jpg")
         page = self.obj.page
         # extra stupid pse chunky fix for no metadata
@@ -158,5 +154,5 @@ class OPDS1EntryLinksMixin:
 
         except Exception:
             msg = f"Getting entry links for {self.obj}"
-            LOG.exception(msg)
+            logger.exception(msg)
         return result

codex/views/opds/v1/facets.py

@@ -6,10 +6,11 @@ from typing import Any
 
 from django.urls import reverse
 
+from codex.choices.admin import AdminFlagChoices
 from codex.models import AdminFlag
 from codex.views.browser.browser import BrowserView
 from codex.views.opds.const import MimeType, Rel, UserAgentNames
-from codex.views.opds.util import get_user_agent_name, update_href_query_params
+from codex.views.opds.util import get_user_agent_name
 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
@@ -140,13 +141,15 @@ class OPDS1FacetsView(BrowserView):
 
     def _facet(self, kwargs, facet_group, facet_title, new_query_params):
         kwargs = pop_name(kwargs)
-        href = reverse("opds:v1:feed", kwargs=kwargs)
         facet_active = False
         for key, val in new_query_params.items():
             if self.request.GET.get(key) == val:
                 facet_active = True
                 break
-        href = update_href_query_params(href, self.request.GET, new_query_params)
+        query = {}
+        query.update(self.request.GET)
+        query.update(new_query_params)
+        href = reverse("opds:v1:feed", kwargs=kwargs, query=query)
 
         title = " ".join(filter(None, (facet_group.title_prefix, facet_title))).strip()
         return OPDS1Link(
@@ -222,7 +225,7 @@ class OPDS1FacetsView(BrowserView):
             if facet.value == "f":
                 efv_flag = (
                     AdminFlag.objects.only("on")
-                    .get(key=AdminFlag.FlagChoices.FOLDER_VIEW.value)
+                    .get(key=AdminFlagChoices.FOLDER_VIEW.value)
                     .on
                 )
                 if not efv_flag:
@@ -231,7 +234,7 @@ class OPDS1FacetsView(BrowserView):
                 facets += [facet_obj]
         return facets
 
-    def facets(self, entries: bool, root: bool):
+    def facets(self, *, entries: bool, root: bool):
         # entries false, root true
         """Return facets."""
         facets = []