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

codex/views/browser/metadata.py

@@ -7,7 +7,7 @@ from rest_framework.exceptions import NotFound
 from rest_framework.response import Response
 
 from codex.comic_field_names import COMIC_M2M_FIELD_NAMES
-from codex.models import AdminFlag, Comic
+from codex.models import AdminFlag, Comic, StoryArc
 from codex.serializers.metadata import MetadataSerializer
 from codex.views.auth import IsAuthenticatedOrEnabledNonUsers
 from codex.views.browser.browser_annotations import BrowserAnnotationsView
@@ -28,6 +28,7 @@ class MetadataView(BrowserAnnotationsView):
         "critical_rating",
         "day",
         "file_type",
+        "gtin",
         "issue",
         "issue_suffix",
         "language",
@@ -56,6 +57,7 @@ class MetadataView(BrowserAnnotationsView):
     _COMIC_RELATED_VALUE_FIELDS = {"series__volume_count", "volume__issue_count"}
     _PATH_GROUPS = ("c", "f")
     _CREATOR_RELATIONS = ("role", "person")
+    _STORY_ARC_NUMBER_RELATIONS = ("story_arc",)
 
     def _get_comic_value_fields(self):
         """Include the path field for staff."""
@@ -79,7 +81,7 @@ class MetadataView(BrowserAnnotationsView):
             # Have to use simple_qs because every annotation in the loop
             # corrupts the the main qs
             # If 1 variant, annotate value, otherwise None
-            full_field = field if self.is_model_comic else "comic__" + field
+            full_field = self.rel_prefix + field
 
             sq = (
                 simple_qs.values("id")
@@ -105,7 +107,7 @@ class MetadataView(BrowserAnnotationsView):
     def _annotate_aggregates(self, qs):
         """Annotate aggregate values."""
         if not self.is_model_comic:
-            size_func = self.get_aggregate_func("size", self.is_model_comic)
+            size_func = self.get_aggregate_func(self.model, "size")
             qs = qs.annotate(size=size_func)
         qs = self.annotate_common_aggregates(qs, self.model, {})
         return qs
@@ -135,18 +137,32 @@ class MetadataView(BrowserAnnotationsView):
         )
         return qs
 
-    def _annotate_for_filename(self, qs):
-        """Annotate for the filename function."""
-        if not self.is_model_comic:
-            return qs
-        qs = qs.annotate(parent_folder_pk=F("parent_folder_id"))
-        return qs.annotate(series_name=F("series__name"), volume_name=F("volume__name"))
+    @staticmethod
+    def _get_intersection_queryset(qs, values, count_rel, comic_pks):
+        """Create an intersection queryset."""
+        return (
+            qs.only(*values)
+            .annotate(count=Count(count_rel))
+            .order_by()
+            .filter(count=comic_pks.count())
+        )
+
+    @classmethod
+    def _get_story_arc_intersection_queryset(cls, comic_pks):
+        """Hoist Story Arc intersections up from StoryArcNumber."""
+        qs = StoryArc.objects.filter(storyarcnumber__comic__pk__in=comic_pks)
+        return cls._get_intersection_queryset(
+            qs,
+            ("name",),
+            "storyarcnumber__comic",
+            comic_pks,
+        )
 
     def _query_m2m_intersections(self, simple_qs):
         """Query the through models to figure out m2m intersections."""
         # Speed ok, but still does a query per m2m model
         m2m_intersections = {}
-        pk_field = "pk" if self.is_model_comic else "comic__pk"
+        pk_field = self.rel_prefix + "pk"
         comic_pks = simple_qs.values_list(pk_field, flat=True)
         for field_name in COMIC_M2M_FIELD_NAMES:
             model = Comic._meta.get_field(field_name).related_model
@@ -156,19 +172,28 @@ class MetadataView(BrowserAnnotationsView):
 
             intersection_qs = model.objects.filter(comic__pk__in=comic_pks)
             if field_name == "creators":
+                # XXX This doesn't prevent an n+1 warning
                 intersection_qs = intersection_qs.select_related(
                     *self._CREATOR_RELATIONS
                 )
                 values = self._CREATOR_RELATIONS
+            elif field_name == "story_arc_numbers":
+                # XXX This doesn't prevent an n+1 warning
+                intersection_qs = intersection_qs.select_related(
+                    *self._STORY_ARC_NUMBER_RELATIONS
+                )
+                values = self._STORY_ARC_NUMBER_RELATIONS
+
+                # Extra add on m2m
+                m2m_intersections[
+                    "story_arcs"
+                ] = self._get_story_arc_intersection_queryset(comic_pks)
             else:
                 values = ("name",)
 
             # order_by() is very important for grouping
-            intersection_qs = (
-                intersection_qs.only(*values)
-                .annotate(count=Count("comic"))
-                .order_by()
-                .filter(count=comic_pks.count())
+            intersection_qs = self._get_intersection_queryset(
+                intersection_qs, values, "comic", comic_pks
             )
             m2m_intersections[field_name] = intersection_qs
         return m2m_intersections
@@ -221,7 +246,7 @@ class MetadataView(BrowserAnnotationsView):
 
         # filename
         if self.model == Comic:
-            obj.filename = Comic.get_filename(obj)
+            obj.filename = obj.filename()
 
         return obj
 
@@ -234,7 +259,7 @@ class MetadataView(BrowserAnnotationsView):
         if self.model is None:
             raise NotFound(detail=f"Cannot get metadata for {self.group=}")
 
-        object_filter, _ = self.get_query_filters_without_group(self.is_model_comic)
+        object_filter, _ = self.get_query_filters_without_group(self.model)
         pk = self.kwargs["pk"]
         qs = self.model.objects.filter(object_filter, pk=pk)
 
@@ -242,10 +267,8 @@ class MetadataView(BrowserAnnotationsView):
         simple_qs = qs
 
         qs = self._annotate_values_and_fks(qs, simple_qs)
-        qs = self._annotate_for_filename(qs)
 
         try:
-            # obj = qs.values()[0]
             obj = qs.first()
             if not obj:
                 reason = "Empty obj"
@@ -282,6 +305,8 @@ class MetadataView(BrowserAnnotationsView):
         self.parse_params()
         self.group = self.kwargs["group"]
         self._validate()
+        self.rel_prefix = self.get_rel_prefix(self.model)
+        self.set_order_key()
 
         obj = self.get_object()
 

codex/views/download.py

@@ -25,7 +25,7 @@ class DownloadView(APIView, GroupACLMixin):
         """Download a comic archive."""
         pk = kwargs.get("pk")
         try:
-            group_acl_filter = self.get_group_acl_filter(True)
+            group_acl_filter = self.get_group_acl_filter(Comic)
             comic = (
                 Comic.objects.filter(group_acl_filter)
                 .select_related(*self._DOWNLOAD_SELECT_RELATED)

codex/views/frontend.py

@@ -14,7 +14,6 @@ class IndexView(BrowserSessionViewBase):
 
     def get(self, *args, **kwargs):
         """Get the app index page."""
-        extra_context = {
-            "last_route": self.get_from_session("route"),
-        }
+        last_route = self.get_from_session("route")
+        extra_context = {"last_route": last_route}
         return Response(extra_context)

codex/views/mixins.py

@@ -1,12 +1,15 @@
 """A filter for group ACLS."""
 from django.db.models import Q
 
+from codex.models import Comic, Folder, StoryArc
+
 
 class GroupACLMixin:
     """Filter group ACLS for views."""
 
     ROOT_GROUP = "r"
     FOLDER_GROUP = "f"
+    STORY_ARC_GROUP = "a"
     COMIC_GROUP = "c"
     GROUP_RELATION = {
         "p": "publisher",
@@ -15,12 +18,22 @@ class GroupACLMixin:
         "v": "volume",
         COMIC_GROUP: "pk",
         FOLDER_GROUP: "parent_folder",
+        STORY_ARC_GROUP: "story_arc_numbers__story_arc",
     }
 
-    def get_group_acl_filter(self, is_comic_model):
+    def get_rel_prefix(self, model):
+        """Return the relation prfiex for most fields."""
+        prefix = ""
+        if model != Comic:
+            if model == StoryArc:
+                prefix += "storyarcnumber__"
+            prefix += "comic__"
+        return prefix
+
+    def get_group_acl_filter(self, model):
         """Generate the group acl filter for comics."""
         # The rel prefix
-        prefix = "" if is_comic_model else "comic__"
+        prefix = self.get_rel_prefix(model) if model != Folder else ""
         groups_rel = f"{prefix}library__groups"
 
         # Libraries with no groups are always visible

codex/views/opds/const.py

@@ -15,6 +15,7 @@ class Rel:
     IMAGE = "http://opds-spec.org/image"
     STREAM = "http://vaemendis.net/opds-pse/stream"
     SORT_NEW = "http://opds-spec.org/sort/new"
+    POPULAR = "http://opds-spec.org/sort/popular"
     FEATURED = "http://opds-spec.org/featured"
     SELF = "self"
     START = "start"
@@ -40,7 +41,6 @@ class MimeType:
     ENTRY_CATALOG = ";".join((ATOM, "type=entry", _PROFILE_CATALOG))
     AUTHENTICATION = "application/opds-authentication+json"
     OPENSEARCH = "application/opensearchdescription+xml"
-    DOWNLOAD = "application/zip"  # PocketBooks needs app/zip
     STREAM = "image/jpeg"
     OPDS_JSON = "application/opds+json"
     OPDS_PUB = "application/opds-publication+json"
@@ -57,4 +57,11 @@ class MimeType:
         "CBT": "application/vnd.comicbook+tar",
         "PDF": "application/pdf",
     }
+    SIMPLE_FILE_TYPE_MAP = {
+        # PocketBooks needs app/zip
+        "CBZ": "application/zip",
+        "CBR": "application/x-rar-compressed",
+        "CBT": "application/x-tar",
+        "PDF": "application/pdf",
+    }
     OCTET = "application/octet-stream"

codex/views/opds/util.py

@@ -1,5 +1,7 @@
 """OPDS Utility classes."""
 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.models import (
@@ -13,6 +15,7 @@ from codex.models import (
     Tag,
     Team,
 )
+from codex.serializers.choices import DEFAULTS
 
 OPDS_M2M_MODELS = (Character, Genre, Location, SeriesGroup, StoryArc, Tag, Team)
 
@@ -61,6 +64,39 @@ def get_m2m_objects(pk) -> dict:
     cats = {}
     for model in OPDS_M2M_MODELS:
         table = model.__name__.lower()
-        qs = model.objects.filter(comic=pk).order_by("name").only("name")
+        rel = "comic"
+        if model == StoryArc:
+            rel = "storyarcnumber__" + rel
+        comic_filter = {rel: pk}
+        qs = model.objects.filter(**comic_filter).order_by("name").only("name")
         cats[table] = qs
+
     return cats
+
+
+def full_redirect_view(url_name):
+    """Redirect to view, for a url name."""
+
+    def func(request):
+        """Redirect to view, forwarding query strings and auth."""
+        kwargs = DEFAULTS["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)
+
+        response = HttpResponseRedirect(url)
+
+        # Forward authorization.
+        auth_header = request.META.get("HTTP_AUTHORIZATION")
+        if auth_header:
+            response["HTTP_AUTHORIZATION"] = auth_header
+
+        return response
+
+    return func

codex/views/opds/v1/__init__.py

@@ -1 +1 @@
-"""OPDS 1 Views."""
+"""OPDS v1 Views."""

codex/views/opds/v1/data.py

@@ -0,0 +1,21 @@
+"""OPDS v1 Data classes."""
+from dataclasses import dataclass
+from datetime import datetime
+from typing import Optional
+
+
+@dataclass
+class OPDS1Link:
+    """An OPDS Link."""
+
+    rel: str
+    href: str
+    mime_type: str
+    title: str = ""
+    length: int = 0
+    facet_group: str = ""
+    facet_active: bool = False
+    thr_count: int = 0
+    pse_count: int = 0
+    pse_last_read: int = 0
+    pse_last_read_date: Optional[datetime] = None

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

@@ -0,0 +1 @@
+"""OPDS v1 Entries."""

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

@@ -0,0 +1,23 @@
+"""OPDS v1 Entry Data classes."""
+from dataclasses import dataclass
+
+
+@dataclass
+class OPDS1EntryObject:
+    """Fake entry db object for top link & facet entries."""
+
+    group: str = ""
+    pk: int = 0
+    name: str = ""
+    summary: str = ""
+    fake: bool = True
+
+
+@dataclass
+class OPDS1EntryData:
+    """Entry Data class to avoid to many args."""
+
+    acquisition_groups: frozenset
+    issue_max: int
+    metadata: bool
+    mime_type_map: dict

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

@@ -0,0 +1,151 @@
+"""OPDS v1 Entry."""
+import json
+from datetime import datetime, timezone
+from urllib.parse import urlencode
+
+from django.urls import reverse
+
+from codex.logger.logging 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_creator_people,
+    get_m2m_objects,
+)
+from codex.views.opds.v1.entry.links import OPDS1EntryLinksMixin
+
+LOG = get_logger(__name__)
+
+
+class OPDS1Entry(OPDS1EntryLinksMixin):
+    """An OPDS entry object."""
+
+    _DATE_FORMAT_BASE = "%Y-%m-%dT%H:%M:%S"
+    _DATE_FORMAT_MS = _DATE_FORMAT_BASE + ".%f%z"
+    _DATE_FORMAT = _DATE_FORMAT_BASE + "%z"
+    _DATE_FORMATS = (_DATE_FORMAT_MS, _DATE_FORMAT)
+
+    @property
+    def id_tag(self):
+        """GUID is a nav url."""
+        # Id top links by query params but not regular entries.
+        return self._nav_href(metadata=self.metadata)
+
+    @property
+    def title(self):
+        """Compute the item title."""
+        result = ""
+        try:
+            parts = []
+            if not self.fake:
+                group = self.obj.group
+                if group == "i":
+                    parts.append(self.obj.publisher_name)
+                elif group == "v":
+                    parts.append(self.obj.series_name)
+                elif group == "c":
+                    title = Comic.get_title(self.obj, issue_max=self.issue_max)
+                    parts.append(title)
+
+            if name := self.obj.name:
+                parts.append(name)
+
+            result = " ".join(filter(None, parts))
+        except Exception as exc:
+            LOG.exception(exc)
+
+        if not result:
+            result = BLANK_TITLE
+        return result
+
+    @property
+    def issued(self):
+        """Return the published date."""
+        if self.obj.group == "c":
+            return self.obj.date
+        return None
+
+    @property
+    def publisher(self):
+        """Return the publisher."""
+        return self.obj.publisher_name
+
+    def _get_datefield(self, key):
+        result = None
+        if not self.fake and (value := getattr(self.obj, key, None)):
+            for date_format in self._DATE_FORMATS:
+                try:
+                    if isinstance(value, str):
+                        result = datetime.strptime(value, date_format).astimezone(
+                            timezone.utc
+                        )
+                    if isinstance(value, datetime):
+                        result = value.astimezone(timezone.utc).strftime(date_format)
+                    break
+                except ValueError:
+                    pass
+        return result
+
+    @property
+    def updated(self):
+        """When the entry was last updated."""
+        return self._get_datefield("updated_at")
+
+    @property
+    def published(self):
+        """When the entry was created."""
+        return self._get_datefield("created_at")
+
+    @property
+    def language(self):
+        """Return the entry language."""
+        return self.obj.language
+
+    @property
+    def summary(self):
+        """Return a child count or comic summary."""
+        if self.obj.group == "c":
+            desc = self.obj.summary
+        else:
+            children = self.obj.child_count
+            desc = f"{children} issues"
+        return desc
+
+    @staticmethod
+    def _add_url_to_obj(objs, filter_key):
+        """Add filter urls to objects."""
+        kwargs = {"group": "s", "pk": 0, "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
+            result.append(obj)
+        return result
+
+    @property
+    def authors(self):
+        """Get Author names."""
+        if not self.metadata:
+            return []
+        people = get_creator_people(self.obj.pk, AUTHOR_ROLES)
+        return self._add_url_to_obj(people, "creators")
+
+    @property
+    def contributors(self):
+        """Get Contributor names."""
+        if not self.metadata:
+            return []
+        people = get_creator_people(self.obj.pk, AUTHOR_ROLES, exclude=True)
+        return self._add_url_to_obj(people, "creators")
+
+    @property
+    def category_groups(self):
+        """Get Category labels."""
+        if not self.metadata:
+            return {}
+        return get_m2m_objects(self.obj.pk)

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

@@ -0,0 +1,135 @@
+"""OPDS v1 Entry Links Methods."""
+from urllib.parse import quote_plus
+
+from django.contrib.staticfiles.storage import staticfiles_storage
+from django.urls import reverse
+
+from codex.models import Comic
+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
+
+
+class OPDS1EntryLinksMixin:
+    """OPDS v1 Entry Links Methods."""
+
+    def __init__(self, obj, query_params, data: OPDS1EntryData):
+        """Initialize params."""
+        self.obj = obj
+        self.fake = isinstance(self.obj, OPDS1EntryObject)
+        self.query_params = query_params
+        self.acquision_groups = data.acquisition_groups
+        self.issue_max = data.issue_max
+        self.metadata = data.metadata
+        self.mime_type_map = data.mime_type_map
+
+    def _thumb_link(self):
+        if self.fake:
+            return None
+        cover_pk = self.obj.cover_pk
+        if cover_pk:
+            kwargs = {"pk": cover_pk}
+            href = reverse("opds:bin:cover", kwargs=kwargs)
+        elif cover_pk == 0:
+            href = staticfiles_storage.url("img/missing_cover.webp")
+        else:
+            return None
+        return OPDS1Link(Rel.THUMBNAIL, href, "image/webp")
+
+    def _image_link(self):
+        if self.fake:
+            return None
+        cover_pk = self.obj.cover_pk
+        if cover_pk:
+            kwargs = {"pk": cover_pk, "page": 0}
+            href = reverse("opds:bin:page", kwargs=kwargs)
+            mime_type = "image/jpeg"
+        elif cover_pk == 0:
+            href = staticfiles_storage.url("img/missing_cover.webp")
+            mime_type = "image/webp"
+        else:
+            return None
+        return OPDS1Link(Rel.IMAGE, href, mime_type)
+
+    def _nav_href(self, metadata=False):
+        kwargs = {"group": self.obj.group, "pk": self.obj.pk, "page": 1}
+        href = reverse("opds:v1:feed", kwargs=kwargs)
+        qps = {}
+        if (
+            self.obj.group == "a"
+            and self.obj.pk
+            and not self.query_params.get("orderBy")
+        ):
+            # story arcs get ordered by story_arc_number by default
+            qps.update({"orderBy": "story_arc_number"})
+        if metadata:
+            qps.update({"opdsMetadata": 1})
+        return update_href_query_params(href, self.query_params, qps)
+
+    def _nav_link(self, metadata=False):
+        group = self.obj.group
+
+        if group in self.acquision_groups:
+            mime_type = MimeType.ENTRY_CATALOG if metadata else MimeType.ACQUISITION
+        else:
+            mime_type = MimeType.NAV
+
+        href = self._nav_href(metadata)
+        thr_count = 0 if self.fake else self.obj.child_count
+        rel = Rel.ALTERNATE if metadata else "subsection"
+
+        return OPDS1Link(rel, href, mime_type, thr_count=thr_count)
+
+    def _download_link(self):
+        pk = self.obj.pk
+        if not pk:
+            return None
+        fn = Comic.get_filename(self.obj)
+        fn = quote_plus(fn)
+        kwargs = {"pk": pk, "filename": fn}
+        href = reverse("opds:bin:download", kwargs=kwargs)
+        mime_type = self.mime_type_map.get(self.obj.file_type, MimeType.OCTET)
+        return OPDS1Link(Rel.ACQUISITION, href, mime_type, length=self.obj.size)
+
+    def _stream_link(self):
+        pk = self.obj.pk
+        if not pk:
+            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 = href.replace("0/page.jpg", "{pageNumber}/page.jpg")
+        page = self.obj.page
+        count = self.obj.page_count
+        bookmark_updated_at = self.obj.bookmark_updated_at
+        return OPDS1Link(
+            Rel.STREAM,
+            href,
+            MimeType.STREAM,
+            pse_count=count,
+            pse_last_read=page,
+            pse_last_read_date=bookmark_updated_at,
+        )
+
+    @property
+    def links(self):
+        """Create all entry links."""
+        result = []
+        if thumb := self._thumb_link():
+            result += [thumb]
+        if image := self._image_link():
+            result += [image]
+
+        if self.obj.group == "c" and not self.fake:
+            if download := self._download_link():
+                result += [download]
+            if stream := self._stream_link():
+                result += [stream]
+            if not self.metadata and (metadata := self._nav_link(metadata=True)):
+                result += [metadata]
+        elif nav := self._nav_link():
+            result += [nav]
+
+        return result