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

codex/views/reader/params.py

@@ -3,27 +3,12 @@
 from types import MappingProxyType
 from typing import Any
 
-from codex.logger.logger import get_logger
-from codex.models import Comic
-from codex.serializers.reader import (
-    ReaderViewInputSerializer,
-)
+from loguru import logger
+
+from codex.serializers.fields.reader import VALID_ARC_GROUPS
+from codex.serializers.reader import ReaderViewInputSerializer
 from codex.util import mapping_to_dict
-from codex.views.const import FOLDER_GROUP, GROUP_RELATION, STORY_ARC_GROUP
 from codex.views.session import SessionView
-from codex.views.util import reparse_json_query_params
-
-LOG = get_logger(__name__)
-VALID_ARC_GROUPS = "pisvfa"
-_JSON_KEYS = frozenset({"arc", "breadcrumbs", "browserArc", "show"})
-_BROWSER_SESSION_DEFAULTS = SessionView.SESSION_DEFAULTS[
-    SessionView.BROWSER_SESSION_KEY
-]
-_DEFAULT_PARAMS = {
-    "breadcrumbs": _BROWSER_SESSION_DEFAULTS["breadcrumbs"],
-    "show": _BROWSER_SESSION_DEFAULTS["show"],
-    "top_group": _BROWSER_SESSION_DEFAULTS["top_group"],
-}
 
 
 class ReaderParamsView(SessionView):
@@ -37,98 +22,50 @@ class ReaderParamsView(SessionView):
         self._group_pks: dict[str, tuple[int, ...]] = {}
         self._params: MappingProxyType[str, Any] | None = None
 
-    def _get_group_pks_from_breadcrumbs(self, groups, breadcrumbs):
-        """Set Multi-Group pks from breadcrumbs to the cache."""
-        index = len(breadcrumbs) - 1
-        min_index = max(index - 1, 0) if FOLDER_GROUP in groups else 0
-        while index > min_index:
-            crumb = breadcrumbs[index]
-            crumb_group = crumb.get("group")
-            if crumb_group in groups:
-                pks = crumb.get("pks", ())
-                self._group_pks[crumb_group] = pks
-                break
-            index -= 1
-        else:
-            crumb_group = ""
-            pks = ()
-            for group in groups:
-                self._group_pks[group] = pks
-        return crumb_group, pks
-
-    def get_group_pks_from_breadcrumbs(self, groups, params=None):
-        """Get Multi-Group pks from the breadcrumbs."""
-        # Return cached values
-        for group in groups:
-            pks = self._group_pks.get(group)
-            if pks is not None:
-                return group, pks
-
-        if params is None:
-            params = self.params
-        breadcrumbs: tuple = params.get("breadcrumbs", ())
-
-        return self._get_group_pks_from_breadcrumbs(groups, breadcrumbs)
-
-    def _ensure_arc_contains_comic(self, params):
-        """Arc sanity check."""
-        arc = params.get("arc")
-        if not arc:
-            return
-        pk = self.kwargs["pk"]
-        arc_group = arc.get("group")
-        arc_pks = arc.get("pks")
-        valid = False
-        if rel := GROUP_RELATION.get(arc_group):
-            rel += "__in"
-            arc_filter = {rel: arc_pks}
-            valid = Comic.objects.filter(pk=pk, **arc_filter).exists()
-        if not valid:
-            LOG.warning(f"Comic {pk} not in arc {arc} submitted to reader.")
-            params.pop("arc", None)
-
-    def _ensure_arc(self, params):
-        """arc.group validation."""
-        # Can't be in the serializer
+    def _ensure_arc_group(self, params: dict[str, Any]):
         arc = params.get("arc", {})
+        group = arc.get("group", "")
+        if not group:
+            top_group = self.get_from_session(
+                "top_group", session_key=self.BROWSER_SESSION_KEY
+            )
+            group = "s" if top_group in "rpi" else top_group
+        if group not in VALID_ARC_GROUPS:
+            group = "s"
+        params["arc"]["group"] = group
+
+    @staticmethod
+    def _ensure_arc_ids(params: dict[str, Any]):
+        arc = params.get("arc", {})
+        if ids := arc.get("ids"):
+            ids = tuple(sorted(set(filter(lambda x: x > 0, ids))))
+        else:
+            ids = ()
+        params["arc"]["ids"] = ids
 
-        arc_group = arc.get("group", "")
-        arc_pks = arc.get("pks", ())
-        if arc_group not in VALID_ARC_GROUPS or not arc_pks:
-            top_group = params["top_group"]
-            if top_group in FOLDER_GROUP + STORY_ARC_GROUP:
-                search_groups = (top_group,)
-            else:
-                search_groups = "vsip"
-
-            group, pks = self.get_group_pks_from_breadcrumbs(search_groups, params)
-            if not group:
-                group = "s"
-
-            arc["group"] = group
-            if pks:
-                arc["pks"] = pks
+    def _ensure_arc(self, params: dict[str, Any]) -> None:
+        """Ensure the group is valid."""
+        if "arc" not in params:
+            params["arc"] = {}
 
-        params["arc"] = arc
+        self._ensure_arc_group(params)
+        self._ensure_arc_ids(params)
 
     @property
     def params(self):
         """Memoized params property."""
         if self._params is None:
             try:
-                data = self.request.GET
-                data = reparse_json_query_params(self.request.GET, _JSON_KEYS)
-                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] = mapping_to_dict(_DEFAULT_PARAMS)  # type: ignore[reportAssignmentType]
+                params = mapping_to_dict(dict(self.SESSION_DEFAULTS[self.SESSION_KEY]))
                 if serializer.validated_data:
                     params.update(serializer.validated_data)
-                self._ensure_arc_contains_comic(params)
                 self._ensure_arc(params)
-
+                self.save_params_to_session(params)
                 self._params = MappingProxyType(params)
             except Exception:
-                LOG.exception("validate")
+                logger.exception("validate")
                 raise
         return self._params

codex/views/reader/reader.py

@@ -1,99 +1,44 @@
 """Views for reading comic books."""
 
-from comicbox.box import Comicbox
-from django.urls import reverse
 from drf_spectacular.utils import extend_schema
-from rest_framework.exceptions import NotFound
 from rest_framework.response import Response
+from rest_framework.serializers import BaseSerializer
+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.serializers.reader import ReaderComicsSerializer, ReaderViewInputSerializer
-from codex.serializers.redirect import ReaderRedirectSerializer
-from codex.views.reader.arcs import ReaderArcsView
+from codex.views.reader.books import ReaderBooksView
 
-LOG = get_logger(__name__)
 
-
-class ReaderView(ReaderArcsView):
+class ReaderView(ReaderBooksView):
     """Get info for displaying comic pages."""
 
-    serializer_class = ReaderComicsSerializer
-
-    SESSION_KEY = "reader"
-    TARGET = "reader"
-
-    def _raise_not_found(self):
-        """Raise not found exception."""
-        pk = self.kwargs.get("pk")
-        detail = {
-            "route": reverse("app:start"),
-            "reason": f"comic {pk} not found",
-            "serializer": ReaderRedirectSerializer,
-        }
-        raise NotFound(detail=detail)
-
-    @staticmethod
-    def _lazy_metadata(current, prev_book, next_book):
-        """Get reader metadata from comicbox if it's not in the db."""
-        import_pks = set()
-        if current and not (current.page_count and current.file_type):
-            with Comicbox(current.path) as cb:
-                current.file_type = cb.get_file_type()
-                current.page_count = cb.get_page_count()
-            import_pks.add(current.pk)
+    serializer_class: type[BaseSerializer] | None = ReaderComicsSerializer
 
-        if prev_book and not prev_book.page_count:
-            with Comicbox(prev_book.path) as cb:
-                prev_book.page_count = cb.get_page_count()
-            import_pks.add(prev_book.pk)
-
-        if next_book and not next_book.page_count:
-            with Comicbox(next_book.path) as cb:
-                next_book.page_count = cb.get_page_count()
-            import_pks.add(next_book.pk)
-
-        if import_pks:
-            task = LazyImportComicsTask(frozenset(import_pks))
-            LIBRARIAN_QUEUE.put(task)
+    SESSION_KEY: str = "reader"
+    TARGET: str = "reader"
 
+    @override
     def get_object(self):
         """Get the previous and next comics in a group or story arc."""
+        # Arcs
+        arcs, mtime = self.get_arcs()
+
         # Books
         books = self.get_book_collection()
 
-        current = books.get("current")
-        if not current:
-            self._raise_not_found()
-
-        prev_book = books.get("prev")
-        next_book = books.get("next")
-        self._lazy_metadata(current, prev_book, next_book)
+        close_route = self.get_last_route(name=True)
 
-        books = {
-            "current": current,
-            "prev_book": prev_book,
-            "next_book": next_book,
+        arc = {
+            "group": self._selected_arc_group,
+            "ids": self._selected_arc_ids,
+            "index": self._selected_arc_index,
+            "count": self._selected_arc_count,
         }
 
-        # Arcs
-        arcs, mtime = self.get_arcs(current)
-
-        arc = self.params.get("arc", {})
-        if not arc.get("group"):
-            arc["group"] = current.arc_group
-        if not arc.get("pks"):
-            arc["pks"] = (current.arc_pk,)
-        arc["index"] = current.arc_index
-        arc["count"] = current.arc_count
-
-        close_route = self.get_last_route(name=True)
-
         return {
-            "books": books,
             "arcs": arcs,
             "arc": arc,
+            "books": books,
             "close_route": close_route,
             "mtime": mtime,
         }

codex/views/reader/settings.py

@@ -1,5 +1,7 @@
 """Reader session view."""
 
+from rest_framework.serializers import BaseSerializer
+
 from codex.serializers.reader import ReaderSettingsSerializer
 from codex.views.settings import SettingsView
 
@@ -7,6 +9,6 @@ from codex.views.settings import SettingsView
 class ReaderSettingsView(SettingsView):
     """Get Reader Settings."""
 
-    serializer_class = ReaderSettingsSerializer
+    serializer_class: type[BaseSerializer] | None = ReaderSettingsSerializer
 
-    SESSION_KEY = "reader"
+    SESSION_KEY: str = "reader"

codex/views/session.py

@@ -3,31 +3,25 @@
 from abc import ABC
 from copy import deepcopy
 from types import MappingProxyType
-from typing import TYPE_CHECKING
+
+from loguru import logger
 
 from codex.choices.browser import BROWSER_DEFAULTS
 from codex.choices.reader import READER_DEFAULTS
-from codex.logger.logger import get_logger
 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"
+CREDIT_PERSON_UI_FIELD = "credits"
 STORY_ARC_UI_FIELD = "story_arcs"
-IDENTIFIER_TYPE_UI_FIELD = "identifier_type"
+IDENTIFIER_TYPE_UI_FIELD = "identifier_source"
 
 _DYNAMIC_FILTER_DEFAULTS = MappingProxyType(
     {
         "age_rating": [],
         "characters": [],
         "country": [],
-        CONTRIBUTOR_PERSON_UI_FIELD: [],
-        "community_rating": [],
+        CREDIT_PERSON_UI_FIELD: [],
         "critical_rating": [],
         "decade": [],
         "file_type": [],
@@ -44,6 +38,7 @@ _DYNAMIC_FILTER_DEFAULTS = MappingProxyType(
         "tagger": [],
         "tags": [],
         "teams": [],
+        "universes": [],
         "year": [],
     }
 )
@@ -53,8 +48,8 @@ class SessionView(AuthFilterGenericAPIView, ABC):
     """Generic Session View."""
 
     # Must override this
-    SESSION_KEY = ""
-    FILTER_ATTRIBUTES = frozenset(_DYNAMIC_FILTER_DEFAULTS.keys())
+    SESSION_KEY: str = ""
+    FILTER_ATTRIBUTES: frozenset[str] = frozenset(_DYNAMIC_FILTER_DEFAULTS.keys())
     BROWSER_SESSION_KEY = "browser"
     READER_SESSION_KEY = "reader"
     SESSION_DEFAULTS = MappingProxyType(
@@ -83,16 +78,14 @@ class SessionView(AuthFilterGenericAPIView, ABC):
             default = self.SESSION_DEFAULTS[session_key][key]
         return session.get(key, default)
 
-    def get_last_route(self, name: bool):
+    def get_last_route(self, *, name: bool):
         """Get the last route from the breadcrumbs."""
+        breadcrumbs: tuple
         breadcrumbs = self.get_from_session(
             "breadcrumbs", session_key=self.BROWSER_SESSION_KEY
         )
         if not breadcrumbs:
-            default_breadcrumbs: tuple[
-                Mapping[str, str | tuple[int, ...] | int], ...
-            ] = BROWSER_DEFAULTS["breadcrumbs"]  # type: ignore[reportAssignmentType]
-            breadcrumbs = default_breadcrumbs
+            breadcrumbs = BROWSER_DEFAULTS["breadcrumbs"]  # pyright: ignore[reportAssignmentType]
         last_route = breadcrumbs[-1]
         if not name:
             last_route = pop_name(last_route)
@@ -138,7 +131,8 @@ class SessionView(AuthFilterGenericAPIView, ABC):
             params = deepcopy(dict(params))
             defaults = mapping_to_dict(self.SESSION_DEFAULTS[self.SESSION_KEY])
             data = self._get_source_values_or_set_defaults(defaults, params, {})
+            data = mapping_to_dict(data)
             self.request.session[self.SESSION_KEY] = data
             self.request.session.save()
         except Exception as exc:
-            LOG.warning(f"Saving params to session: {exc}")
+            logger.warning(f"Saving params to session: {exc}")

codex/views/settings.py

@@ -5,28 +5,23 @@ from abc import ABC
 from drf_spectacular.utils import extend_schema
 from rest_framework.response import Response
 
-from codex.serializers.settings import SettingsSerializer
+from codex.serializers.settings import SettingsInputSerializer
 from codex.views.session import SessionView
-from codex.views.util import reparse_json_query_params
-
-_GET_JSON_PARAMS = frozenset({"only"})
 
 
 class SettingsView(SessionView, ABC):
     """Settings View."""
 
-    input_serializer_class = SettingsSerializer
+    input_serializer_class: type[SettingsInputSerializer] = SettingsInputSerializer
 
     def validate_settings_get(self, _validated_data, params: dict) -> dict:
         """Change bad settings."""
         return params
 
-    @extend_schema(parameters=[SettingsSerializer])
+    @extend_schema(parameters=[SettingsInputSerializer])
     def get(self, *args, **kwargs):
         """Get session settings."""
-        data = self.request.GET
-        data = reparse_json_query_params(data, _GET_JSON_PARAMS)
-        serializer = self.input_serializer_class(data=data)
+        serializer = self.input_serializer_class(data=self.request.GET)
         serializer.is_valid(raise_exception=True)
         validated_data = serializer.validated_data
         only = validated_data.get("only") if validated_data else None

codex/views/template.py

@@ -1,7 +1,9 @@
 """Generic Codex Template View."""
 
+from collections.abc import Sequence
+
 from rest_framework import status
-from rest_framework.renderers import TemplateHTMLRenderer
+from rest_framework.renderers import BaseRenderer, TemplateHTMLRenderer
 from rest_framework.response import Response
 from rest_framework.views import APIView
 
@@ -29,12 +31,14 @@ class CodexAPIView(APIView):
 class CodexTemplateView(CodexAPIView):
     """HTML Template View."""
 
-    renderer_classes = (TemplateHTMLRenderer,)
+    renderer_classes: Sequence[type[BaseRenderer]] = (TemplateHTMLRenderer,)
+
     content_type = "text/html"
 
 
-class CodexXMLTemplateView(CodexAPIView):
+class CodexXMLTemplateMixin:
     """XML Template View."""
 
-    renderer_classes = (TemplateXMLRenderer,)
+    renderer_classes: Sequence[type[BaseRenderer]] = (TemplateXMLRenderer,)
+
     content_type = "application/xml"

codex/views/timezone.py

@@ -1,21 +1,20 @@
 """Set timezone from browser endpoint."""
 
 from drf_spectacular.utils import extend_schema
+from loguru import logger
 from rest_framework.response import Response
+from rest_framework.serializers import BaseSerializer
 
-from codex.logger.logger import get_logger
 from codex.serializers.auth import TimezoneSerializer
 from codex.serializers.mixins import OKSerializer
 from codex.views.auth import AuthGenericAPIView
 
-LOG = get_logger(__name__)
-
 
 class TimezoneView(AuthGenericAPIView):
     """User info."""
 
     input_serializer_class = TimezoneSerializer
-    serializer_class = OKSerializer
+    serializer_class: type[BaseSerializer] | None = OKSerializer
 
     def _save_timezone(self, django_timezone):
         """Save django timezone in session."""
@@ -36,7 +35,7 @@ class TimezoneView(AuthGenericAPIView):
             self._save_timezone(timezone)
         except Exception as exc:
             reason = f"update user timezone {exc}"
-            LOG.warning(reason)
+            logger.warning(reason)
 
         serializer = self.get_serializer()
         return Response(serializer.data)

codex/views/util.py

@@ -1,15 +1,9 @@
 """Utility classes by many views."""
 
-import json
 from collections.abc import Mapping
-from contextlib import suppress
 from dataclasses import dataclass
-from json.decoder import JSONDecodeError
-from typing import Any
-from urllib.parse import unquote_plus
 
-from djangorestframework_camel_case.settings import api_settings
-from djangorestframework_camel_case.util import underscoreize
+from typing_extensions import override
 
 # Maximum cover size is around 24 Kb
 DEFAULT_CHUNK_SIZE = 64 * 1024  # 64 Kb
@@ -24,12 +18,14 @@ class Route:
     page: int = 1
     name: str = ""
 
+    @override
     def __hash__(self):
         """Breadcrumb hash."""
         pk_parts = tuple(sorted(set(self.pks)))
         parts = (self.group, pk_parts, self.page)
         return hash(parts)
 
+    @override
     def __eq__(self, cmp):
         """Breadcrumb equality."""
         return cmp and hash(self) == hash(cmp)
@@ -43,23 +39,6 @@ class Route:
         )
 
 
-def reparse_json_query_params(query_params, keys) -> dict[str, Any]:
-    """Reparse JSON encoded query_params."""
-    # It is an unbelievable amount of trouble to try to parse axios native bracket
-    # encoded complex objects in python
-    parsed_dict = {}
-    for key, value in query_params.items():
-        if key in keys:
-            parsed_value = unquote_plus(value)
-            with suppress(JSONDecodeError):
-                parsed_value = json.loads(parsed_value)
-        else:
-            parsed_value = value
-
-        parsed_dict[key] = parsed_value
-    return dict(underscoreize(parsed_dict, **api_settings.JSON_UNDERSCOREIZE))  # type:ignore[reportReturnType]
-
-
 def pop_name(kwargs: Mapping):
     """Pop name from a mapping route."""
     kwargs = dict(kwargs)

codex/views/version.py

@@ -1,8 +1,9 @@
 """Version View."""
 
 from rest_framework.response import Response
+from typing_extensions import override
 
-from codex.librarian.janitor.tasks import JanitorLatestVersionTask
+from codex.librarian.bookmark.tasks import CodexLatestVersionTask
 from codex.librarian.mp_queue import LIBRARIAN_QUEUE
 from codex.models import Timestamp
 from codex.serializers.versions import VersionsSerializer
@@ -15,13 +16,14 @@ class VersionView(AuthGenericAPIView):
 
     serializer_class = VersionsSerializer
 
+    @override
     def get_object(self) -> dict[str, str]:
         """Get the versions."""
-        ts = Timestamp.objects.get(key=Timestamp.TimestampChoices.CODEX_VERSION.value)
+        ts = Timestamp.objects.get(key=Timestamp.Choices.CODEX_VERSION.value)
         if ts.version:
             latest_version = ts.version
         else:
-            LIBRARIAN_QUEUE.put(JanitorLatestVersionTask())
+            LIBRARIAN_QUEUE.put(CodexLatestVersionTask())
             latest_version = "fetching..."
         return {"installed": VERSION, "latest": latest_version}
 

codex/websockets/consumers.py

@@ -3,13 +3,11 @@
 from enum import Enum
 
 from channels.generic.websocket import AsyncWebsocketConsumer
-
-from codex.logger.logger import get_logger
+from loguru import logger
+from typing_extensions import override
 
 ChannelGroups = Enum("ChannelGroups", "ALL ADMIN")
 
-LOG = get_logger(__name__)
-
 
 class NotifierConsumer(AsyncWebsocketConsumer):
     """Base Notifier Consumer."""
@@ -31,15 +29,17 @@ class NotifierConsumer(AsyncWebsocketConsumer):
             groups += [ChannelGroups.ADMIN.name]
         return groups
 
+    @override
     async def websocket_connect(self, message):
         """Authorize with user and connect websocket to groups."""
         # Authorization
         # Set groups for user.
-        self.groups = self._get_groups()
+        self.groups: list[str] | None = self._get_groups()
 
         await super().websocket_connect(message)
-        LOG.debug(f"Websocket connected to {self.groups}")
+        logger.trace(f"Websocket connected to {self.groups}")
 
+    @override
     async def disconnect(self, code):
         """Close channels after WebSocket disconnect."""
         await self.close(code)
@@ -48,6 +48,6 @@ class NotifierConsumer(AsyncWebsocketConsumer):
         """Send message to client."""
         text = event.get("text")
         if not text:
-            LOG.warning(f"No text in websockets message: {event}")
+            logger.warning(f"No text in websockets message: {event}")
             return
         await self.send(text)

codex/websockets/listener.py

@@ -7,11 +7,10 @@ from channels.exceptions import InvalidChannelLayerError
 from channels.layers import get_channel_layer
 from wsproto.frame_protocol import CloseReason
 
-from codex.logger_base import LoggerBaseMixin
 from codex.websockets.consumers import ChannelGroups
 
 
-class BroadcastListener(LoggerBaseMixin):
+class BroadcastListener:
     """Listens to the Broadcast Queue and sends its messages to channels."""
 
     _WS_DISCONNECT_EVENT = MappingProxyType(
@@ -24,9 +23,9 @@ class BroadcastListener(LoggerBaseMixin):
         }
     )
 
-    def __init__(self, queue, log_queue):
+    def __init__(self, logger_, queue):
         """Initialize."""
-        self.init_logger(log_queue)
+        self.log = logger_
         self.queue = queue
         self.channel_layer = get_channel_layer()
 
@@ -53,7 +52,7 @@ class BroadcastListener(LoggerBaseMixin):
 
     async def listen(self):
         """Listen to the broadcast queue until a shutdown message."""
-        self.log.info(f"{self.__class__.__name__} started.")
+        self.log.success(f"{self.__class__.__name__} started.")
         while True:
             try:
                 event = await self.queue.coro_get()