codex 1.4.0a0__py3-none-any.whl → 1.4.1__py3-none-any.whl

codex/views/opds/v2/feed.py

@@ -1,4 +1,4 @@
-"""OPDS 2.0 Feed."""
+"""OPDS v2.0 Feed."""
 from datetime import datetime, timezone
 
 from drf_spectacular.utils import extend_schema
@@ -6,6 +6,7 @@ from rest_framework.authentication import BasicAuthentication, SessionAuthentica
 from rest_framework.response import Response
 
 from codex.logger.logging import get_logger
+from codex.models import AdminFlag
 from codex.serializers.opds.v2 import OPDS2FeedSerializer
 from codex.views.browser.browser import BrowserView
 from codex.views.opds.const import BLANK_TITLE, FALSY
@@ -27,6 +28,8 @@ LOG = get_logger(__name__)
 class OPDS2FeedView(PublicationMixin, TopLinksMixin):
     """OPDS 2.0 Feed."""
 
+    DEFAULT_ROUTE_NAME = "opds:v2:feed"
+
     authentication_classes = (BasicAuthentication, SessionAuthentication)
     serializer_class = OPDS2FeedSerializer
 
@@ -45,41 +48,92 @@ class OPDS2FeedView(PublicationMixin, TopLinksMixin):
         return result
 
     def _detect_user_agent(self):
-        # Hacks for individual clients
+        """Hacks for individual clients."""
         user_agent = self.request.headers.get("User-Agent")
         if not user_agent:
             return
 
+    @staticmethod
+    def _is_allowed(link_spec):
+        """Return if the link allowed."""
+        if (
+            getattr(link_spec, "group", None) == "f"
+            or getattr(link_spec, "query_param_value", None) == "f"
+        ):
+            # Folder perms
+            efv_flag = (
+                AdminFlag.objects.only("on")
+                .get(key=AdminFlag.FlagChoices.FOLDER_VIEW.value)
+                .on
+            )
+            if not efv_flag:
+                return False
+        return True
+
+    @staticmethod
+    def _create_link_kwargs(data, link_spec):
+        """Create link kwargs."""
+        if data.group_kwarg:
+            # Nav Groups
+            pk = getattr(link_spec, "pk", 0)
+            kwargs = {"group": link_spec.group, "pk": pk, "page": 1}
+        elif link_spec.query_param_value in ("f", "a"):
+            # Special Facets
+            kwargs = {
+                "group": link_spec.query_param_value,
+                "pk": 0,
+                "page": 1,
+            }
+        else:
+            # Regular Facets
+            kwargs = None
+        return kwargs
+
+    @staticmethod
+    def _create_link_query_params(group_spec, link_spec, kwargs):
+        """Create link query params."""
+        if qp_key := getattr(group_spec, "query_param_key", None):
+            # Facet shorthand with group
+            qps = {qp_key: link_spec.query_param_value}
+        elif ls_qps := getattr(link_spec, "query_params", None):
+            # Nav Group
+            qps = ls_qps
+        else:
+            # Regular Group
+            qps = None
+
+        # Special order by for story_arcs
+        if (
+            kwargs
+            and kwargs.get("group") == "a"
+            and kwargs.get("pk")
+            and (not qps or not qps.get("orderBy"))
+        ):
+            if not qps:
+                qps = {}
+            qps["orderBy"] = "story_arc_number"
+        return qps
+
     def _create_links_section(self, group_specs, data):
         """Create links sections for groups and facets."""
         groups = []
         for group_spec in group_specs:
             link_dict = {}
             for link_spec in group_spec.links:
-                if data.group_kwarg:
-                    # Nav Groups
-                    pk = getattr(link_spec, "pk", 0)
-                    kwargs = {"group": link_spec.group, "pk": pk, "page": 1}
-                else:
-                    # Facets & Regular Groups
-                    kwargs = None
-                rel = data.rel if data.rel else link_spec.rel
+                if not self._is_allowed(link_spec):
+                    continue
 
-                if qp_key := getattr(group_spec, "query_param_key", None):
-                    # Facet shorthand with group
-                    qps = {qp_key: link_spec.query_param_value}
-                elif ls_qps := getattr(link_spec, "query_params", None):
-                    # Nav Group
-                    qps = ls_qps
-                else:
-                    # Regular Group
-                    qps = None
+                kwargs = self._create_link_kwargs(data, link_spec)
+
+                qps = self._create_link_query_params(group_spec, link_spec, kwargs)
 
                 title = getattr(link_spec, "title", "")
                 if not title:
                     title = getattr(link_spec, "name", "")
 
                 href_data = HrefData(kwargs, qps)
+
+                rel = data.rel if data.rel else link_spec.rel
                 link_data = LinkData(rel, href_data, title=title)
                 link = self.link(link_data)
                 self.link_aggregate(link_dict, link)
@@ -117,8 +171,15 @@ class OPDS2FeedView(PublicationMixin, TopLinksMixin):
     def get_object(self):
         """Get the browser page and serialize it for this subclass."""
         group = self.kwargs.get("group")
-        self.acquisition_groups = frozenset(self.valid_nav_groups[-2:])
-        self.is_opds_2_acquisition = group in self.acquisition_groups
+        if group in ("f", "a"):
+            self.acquisition_groups = frozenset()
+        else:
+            self.acquisition_groups = frozenset(self.valid_nav_groups[-2:])
+        if group == "a":
+            pk = self.kwargs["pk"]
+            self.is_opds_2_acquisition = bool(pk)
+        else:
+            self.is_opds_2_acquisition = group in self.acquisition_groups
         self.is_opds_metadata = (
             self.request.query_params.get("opdsMetadata", "").lower() not in FALSY
         )

codex/views/opds/v2/links.py

@@ -1,4 +1,4 @@
-"""Links methods for OPDS 2.0 Feed."""
+"""Links methods for OPDS v2.0 Feed."""
 from copy import deepcopy
 from dataclasses import dataclass
 from typing import Optional

codex/views/opds/v2/publications.py

@@ -1,4 +1,4 @@
-"""Publication Methods for OPDS 2.0 feed."""
+"""Publication Methods for OPDS v2.0 feed."""
 from urllib.parse import quote_plus
 
 from django.contrib.staticfiles.storage import staticfiles_storage

codex/views/opds/v2/top_links.py

@@ -1,4 +1,4 @@
-"""OPDS 2.0 top links section methods."""
+"""OPDS v2.0 top links section methods."""
 from codex.views.opds.const import MimeType, Rel
 from codex.views.opds.v2.links import HrefData, LinkData, LinksMixin
 

codex/views/reader/page.py

@@ -8,11 +8,11 @@ from rest_framework.negotiation import BaseContentNegotiation
 
 from codex.logger.logging import get_logger
 from codex.models import Comic
-from codex.pdf import PDF
 from codex.version import COMICBOX_CONFIG
 from codex.views.bookmark import BookmarkBaseView
 
 LOG = get_logger(__name__)
+PDF_MIME_TYPE = "application/pdf"
 
 
 class IgnoreClientContentNegotiation(BaseContentNegotiation):
@@ -50,23 +50,22 @@ class ReaderPageView(BookmarkBaseView):
 
     def _get_page_image(self):
         """Get the image data and content type."""
-        group_acl_filter = self.get_group_acl_filter(True)
+        group_acl_filter = self.get_group_acl_filter(Comic)
         pk = self.kwargs.get("pk")
         comic = Comic.objects.filter(group_acl_filter).only("path").get(pk=pk)
         page = self.kwargs.get("page")
         if comic.file_type == Comic.FileType.PDF.value:
-            car = PDF(comic.path)
-            content_type = PDF.MIME_TYPE
+            content_type = PDF_MIME_TYPE
         else:
-            car = ComicArchive(comic.path, config=COMICBOX_CONFIG)
             content_type = self.content_type
-        page_image = car.get_page_by_index(page)
+        with ComicArchive(comic.path, config=COMICBOX_CONFIG) as car:
+            page_image = car.get_page_by_index(page)
         return page_image, content_type
 
     @extend_schema(
         responses={
             (200, content_type): OpenApiTypes.BINARY,
-            (200, PDF.MIME_TYPE): OpenApiTypes.BINARY,
+            (200, PDF_MIME_TYPE): OpenApiTypes.BINARY,
         }
     )
     def get(self, *args, **kwargs):

codex/views/reader/reader.py

@@ -1,24 +1,23 @@
 """Views for reading comic books."""
-from django.db.models import F
+from django.db.models import F, IntegerField, Value
 from django.urls import reverse
 from rest_framework.exceptions import NotFound
 from rest_framework.response import Response
 
 from codex.logger.logging import get_logger
-from codex.models import Bookmark, Comic
-from codex.serializers.reader import ReaderInfoSerializer
+from codex.models import AdminFlag, Bookmark, Comic
+from codex.serializers.reader import ReaderComicsSerializer
 from codex.serializers.redirect import ReaderRedirectSerializer
 from codex.views.bookmark import BookmarkBaseView
 from codex.views.session import BrowserSessionViewBase
 
 LOG = get_logger(__name__)
-PAGE_TTL = 60 * 60 * 24
 
 
 class ReaderView(BookmarkBaseView):
     """Get info for displaying comic pages."""
 
-    serializer_class = ReaderInfoSerializer
+    serializer_class = ReaderComicsSerializer
 
     SETTINGS_ATTRS = ("fit_to", "two_pages", "read_in_reverse", "vertical")
     _COMIC_FIELDS = (
@@ -30,103 +29,234 @@ class ReaderView(BookmarkBaseView):
         "volume",
         "read_ltr",
     )
+    _VALID_ARC_GROUPS = frozenset(("f", "s", "a"))
 
-    def _append_with_settings(self, books, book, bookmark_filter):
-        """Get bookmarks and filename and append to book list."""
-        book.settings = (
-            Bookmark.objects.filter(**bookmark_filter, comic=book)
-            .only(*self.SETTINGS_ATTRS)
-            .first()
-        )
-        book.filename = book.filename()
-        books.append(book)
-
-    def _get_comic_query_params(self, pk):
+    def _get_comics_list(self):
         """Get the reader naviation group filter."""
-        session = self.request.session.get(BrowserSessionViewBase.SESSION_KEY, {})
-        top_group = session.get("top_group")
+        arc_group = self.params.get("arc_group")
 
-        select_related_fields = ["series", "volume"]
-        if top_group == "f":
-            rel = "parent_folder__comic"
+        if arc_group == "a":
+            # for story arcs
+            rel = "story_arc_numbers__story_arc"
+            fields = self._COMIC_FIELDS
+            arc_name_rel = "story_arc_numbers__story_arc__name"
+            arc_pk_rel = "story_arc_numbers__story_arc__pk"
+            arc_index = F("story_arc_numbers__number")
+            ordering = ("arc_index", "date", *Comic.ORDERING)
+        elif arc_group == self.FOLDER_GROUP:
+            # folder mode
+            rel = "parent_folder"
+            fields = (*self._COMIC_FIELDS, "parent_folder")
+            arc_pk_rel = "parent_folder__pk"
+            arc_name_rel = "parent_folder__name"
+            arc_index = Value(None, IntegerField())
             ordering = ("path", "pk")
-            select_related_fields += ["parent_folder"]
         else:
-            rel = "series__comic"
+            # browser mode.
+            rel = "series"
+            fields = self._COMIC_FIELDS
+            arc_pk_rel = "series__pk"
+            arc_name_rel = "series__name"
+            arc_index = Value(None, IntegerField())
             ordering = Comic.ORDERING
 
-        return {rel: pk}, ordering, select_related_fields
+        group_acl_filter = self.get_group_acl_filter(Comic)
+        arc_pk = self.params.get("arc_pk")
+        if not arc_pk:
+            rel += "__comic"
+            arc_pk = self.kwargs.get("pk")
+        nav_filter = {rel: arc_pk}
 
-    def _get_group_comics(self):
-        """Get comics for the series or folder."""
-        pk = self.kwargs.get("pk")
-        group_acl_filter = self.get_group_acl_filter(True)
-        (
-            group_nav_filter,
-            ordering,
-            select_related_fields,
-        ) = self._get_comic_query_params(pk)
-
-        return (
+        qs = (
             Comic.objects.filter(group_acl_filter)
-            .filter(**group_nav_filter)
-            .select_related(*select_related_fields)
-            .only(*self._COMIC_FIELDS)
+            .filter(**nav_filter)
+            .prefetch_related("story_arc_numbers__story_arc")
+            .only(*fields)
             .annotate(
                 series_name=F("series__name"),
                 volume_name=F("volume__name"),
                 issue_count=F("volume__issue_count"),
             )
-            .order_by(*ordering)
+            .annotate(
+                arc_pk=F(arc_pk_rel),
+                arc_name=F(arc_name_rel),
+                arc_index=arc_index,
+            )
         )
 
-    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)
+        return qs.order_by(*ordering)
 
-    def get_object(self):
-        """Get the previous and next comics in a series.
+    def _append_with_settings(self, book, bookmark_filter):
+        """Get bookmarks and filename and append to book list."""
+        book.settings = (
+            Bookmark.objects.filter(**bookmark_filter, comic=book)
+            .only(*self.SETTINGS_ATTRS)
+            .first()
+        )
+        return book
+
+    def _get_book_collection(self):
+        """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
         might be even more expensive.
+
+        Yields 1 to 3 books
         """
-        comics = self._get_group_comics()
+        comics = self._get_comics_list()
         bookmark_filter = self.get_bookmark_filter()
-
-        # Select the -1, +1 window around the current issue
-        # Yields 1 to 3 books
-        books = []
+        books = {}
         prev_book = None
         pk = self.kwargs.get("pk")
         for index, book in enumerate(comics):
-            book.series_index = index + 1  # type: ignore
             if books:
                 # after match set next comic and break
-                self._append_with_settings(books, book, bookmark_filter)
+                books["next"] = self._append_with_settings(book, bookmark_filter)
                 break
             if book.pk == pk:
                 # first match. set previous and current comic
                 if prev_book:
-                    self._append_with_settings(books, prev_book, bookmark_filter)
-                self._append_with_settings(books, book, bookmark_filter)
+                    books["prev"] = self._append_with_settings(
+                        prev_book, bookmark_filter
+                    )
+                # create extra current book attrs:
+                if book.arc_index is None:  # type: ignore
+                    book.arc_index = index + 1  # type: ignore
+                book.filename = book.filename()  # type: ignore
+
+                books["current"] = self._append_with_settings(book, bookmark_filter)
             else:
                 # Haven't matched yet, so set the previous comic
                 prev_book = book
+        return books, comics.count()
+
+    def _get_folder_arc(self, book):
+        """Create the folder arc."""
+        efv_flag = (
+            AdminFlag.objects.only("on")
+            .get(key=AdminFlag.FlagChoices.FOLDER_VIEW.value)
+            .on
+        )
 
-        if not books:
+        if efv_flag:
+            folder_arc = {
+                "group": self.FOLDER_GROUP,
+                "pk": book.parent_folder.pk,
+                "name": book.parent_folder.name,
+            }
+        else:
+            folder_arc = None
+        return folder_arc
+
+    def _get_arcs(self, book):
+        """Get all series/folder/story arcs."""
+        # create top arcs
+        folder_arc = self._get_folder_arc(book)
+        series_arc = {"group": "s", "pk": book.series.pk, "name": book.series.name}
+
+        # order top arcs
+        top_group = self.params.get("top_group")
+        if top_group == self.FOLDER_GROUP and folder_arc:
+            arc = folder_arc
+            other_arc = series_arc
+        else:
+            arc = series_arc
+            other_arc = folder_arc
+
+        arcs = []
+        arcs.append(arc)
+        if other_arc:
+            arcs.append(other_arc)
+
+        # story arcs
+        sas = []
+        for san in book.story_arc_numbers.all():
+            sa = san.story_arc
+            arc = {
+                "group": "a",
+                "pk": sa.pk,
+                "name": sa.name,
+            }
+            sas.append(arc)
+        sas = sorted(sas, key=lambda x: x["name"])
+        arcs += sas
+        return arcs
+
+    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)
+
+    def get_object(self):
+        """Get the previous and next comics in a group or story arc."""
+        # Books
+        books, arc_count = self._get_book_collection()
+
+        current = books.get("current")
+        if not current:
             self._raise_not_found()
 
-        return {"books": books, "series_count": comics.count()}
+        prev_book = books.get("prev")
+        next_book = books.get("next")
+        books = {
+            "current": current,
+            "prev_book": prev_book,
+            "next_book": next_book,
+        }
+
+        # Arcs
+        arcs = self._get_arcs(current)
+
+        arc_group = self.params.get("arc_group")
+        arc = {
+            "group": arc_group,
+            "pk": current.arc_pk,  # type: ignore
+            "index": current.arc_index,  # type: ignore
+            "count": arc_count,
+        }
+
+        return {
+            "books": books,
+            "arcs": arcs,
+            "arc": arc,
+        }
+
+    def _parse_params(self):
+        data = self.request.GET
+
+        # PARAMS
+        session = self.request.session.get(BrowserSessionViewBase.SESSION_KEY, {})
+        top_group = session.get("top_group", "s")
+        arc_group = data.get("arcGroup")
+        if not arc_group:
+            arc_group = top_group
+
+        if arc_group not in self._VALID_ARC_GROUPS:
+            arc_group = "s"
+
+        arc_pk = data.get("arcPk")
+        if arc_pk is not None:
+            arc_pk = int(arc_pk)
+        elif top_group == "a":
+            last_route = session.get("route", {})
+            arc_pk = last_route.get("pk")
+
+        params = {
+            "arc_group": arc_group,
+            "arc_pk": arc_pk,
+            "top_group": top_group,
+        }
+        self.params = params
 
     def get(self, *args, **kwargs):
         """Get the book info."""
+        self._parse_params()
         obj = self.get_object()
         serializer = self.get_serializer(obj)
         return Response(serializer.data)

codex/views/session.py

@@ -63,6 +63,7 @@ class BrowserSessionViewBase(SessionViewBaseBase):
 
     SESSION_KEY = "browser"  # type: ignore
     CREATOR_PERSON_UI_FIELD = "creators"
+    STORY_ARC_UI_FIELD = "story_arcs"
     _DYNAMIC_FILTER_DEFAULTS = {
         "age_rating": [],
         "characters": [],
@@ -79,7 +80,7 @@ class BrowserSessionViewBase(SessionViewBaseBase):
         "q": "",
         "read_ltr": [],
         "series_groups": [],
-        "story_arcs": [],
+        STORY_ARC_UI_FIELD: [],
         "tags": [],
         "teams": [],
         "year": [],

{codex-1.4.0a0.dist-info → codex-1.4.1.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: codex
-Version: 1.4.0a0
+Version: 1.4.1
 Summary: A comic archive web server.
 Home-page: https://github.com/ajslater/codex
 License: GPL-3.0-only
@@ -28,27 +28,24 @@ Requires-Dist: aioprocessing (>=2.0.1,<3.0.0)
 Requires-Dist: ansicolors (>=1.1,<2.0)
 Requires-Dist: case-converter (>=1.1.0,<2.0.0)
 Requires-Dist: channels (>=4.0.0,<5.0.0)
-Requires-Dist: comicbox (>=0.6.7,<0.7.0)
+Requires-Dist: comicbox[pdf] (>=0.10.1,<0.11.0)
 Requires-Dist: django (>=4.2,<5.0)
-Requires-Dist: django-cors-headers (>=3.2,<4.0)
+Requires-Dist: django-cors-headers (>=4.0,<5.0)
 Requires-Dist: django-haystack (>=3.2.1,<4.0.0)
 Requires-Dist: django-rest-registration (>=0.8.0,<0.9.0)
-Requires-Dist: django-vite (>=2.0.2,<3.0.0)
+Requires-Dist: django-vite (==2.1.1)
 Requires-Dist: djangorestframework (>=3.11,<4.0)
 Requires-Dist: djangorestframework-camel-case (>=1.3.0,<2.0.0)
 Requires-Dist: drf-spectacular (>=0.26.0,<0.27.0)
-Requires-Dist: filelock (>=3.4.2,<4.0.0)
-Requires-Dist: filetype (>=1.0.12,<2.0.0)
 Requires-Dist: fnvhash (>=0.1,<0.2)
 Requires-Dist: humanfriendly (>=10.0,<11.0)
 Requires-Dist: humanize (>=4.0.0,<5.0.0)
 Requires-Dist: hypercorn[h3] (>=0.14.1,<0.15.0)
 Requires-Dist: psutil (>=5.9.4,<6.0.0)
 Requires-Dist: pycountry (>=22.1,<23.0)
-Requires-Dist: pymupdf (>=1.21.1,<2.0.0)
 Requires-Dist: python-dateutil (>=2.8.2,<3.0.0)
 Requires-Dist: requests (>=2.24,<3.0)
-Requires-Dist: tzlocal (>=4.1,<5.0)
+Requires-Dist: tzlocal (>=5.0,<6.0)
 Requires-Dist: watchdog (>=3.0,<4.0)
 Requires-Dist: websocket_client (>=1.2,<2.0)
 Requires-Dist: whitenoise[brotli] (>=6.0,<7.0)
@@ -163,45 +160,17 @@ packaged for Linux, but here are some instructions:
 
 Unrar as packaged for Alpine Linux v3.14 seems to work on Alpine v3.15
 
-Codex will also prefer to use the `unrar-cffi` package it finds it installed,
-this is not required.
-
 #### Windows
 
 Windows users should use Docker to run Codex until this documentation section is
 complete.
 
-Codex can _probably_ run using Cygwin or the Windows Linux Subsystem but I
-haven't done it yet. Contributions to this documentation accepted on
-[the outstanding issue](https://github.com/ajslater/codex/issues/76) or discord.
-
-##### Windows Linux Subsystem
-
-Untested. Try following the instructions for [Debian](#debian) above.
-
-##### Cygwin
+Codex can _probably_ Windows Linux Subsystem but I haven't done personally
+tested it yet. Try following the instructions for [Debian](#debian) above. There
+may be outstanding platform related bugs.
 
-Untested partial instructions for the brave.
-
-1.  Install [Cygwin](https://www.cygwin.com/).
-2.  Install wget with cygwin.
-3.  Install:
-    - python3.9+
-    - gcc
-    - gcc-g++
-    - libffi-devel
-    - libjpeg-devel
-    - libssl-devel
-    - mpfr
-    - mpc
-    - python3-devel
-    - python39-cffi
-    - python3.9-openssl with cygwin.
-4.  Using a terminal:
-
-```sh
-pip install wheel
-```
+Contributions to this documentation accepted on
+[the outstanding issue](https://github.com/ajslater/codex/issues/76) or discord.
 
 #### Install Codex with pip