codex 1.4.1__py3-none-any.whl → 1.4.3__py3-none-any.whl

codex/views/browser/filters/search.py

@@ -3,6 +3,7 @@ from django.db.models import Q
 from haystack.query import SearchQuerySet
 
 from codex.logger.logging import get_logger
+from codex.models import Comic
 
 LOG = get_logger(__name__)
 
@@ -10,8 +11,17 @@ LOG = get_logger(__name__)
 class SearchFilterMixin:
     """Search Filters Methods."""
 
-    def _get_search_scores(self, text, search_scores):
+    def get_search_scores(self) -> dict:
         """Perform the search and return the scores as a dict."""
+        search_scores = {}
+        text = self.params.get("q", "")  # type: ignore
+        if not text:
+            # for opds 2
+            text = self.params.get("query", "")  # type: ignore
+        text = text.strip()
+        if not text:
+            return search_scores
+
         sqs = SearchQuerySet().auto_query(text)
         comic_scores = sqs.values("pk", "score")
         try:
@@ -22,30 +32,23 @@ class SearchFilterMixin:
         except Exception as exc:
             LOG.warning("While searching:")
             LOG.exception(exc)
+        return search_scores
 
-    def _get_search_query_filter(self, text, search_scores):
+    def _get_search_query_filter(self, model, search_scores: dict):
         """Get the search filter and scores."""
-        rel = self.rel_prefix + "pk__in"  # type: ignore
-        self._get_search_scores(text, search_scores)
+        prefix = "" if model == Comic else self.rel_prefix  # type: ignore
+        rel = prefix + "pk__in"
         query_dict = {rel: search_scores.keys()}
         return Q(**query_dict)
 
-    def get_search_filter(self):
+    def get_search_filter(self, model, search_scores: dict):
         """Preparse search, search and return the filter and scores."""
         search_filter = Q()
-        search_scores = {}
         try:
-            query_string = self.params.get("q", "")  # type: ignore
-            if not query_string:
-                # for opds 2
-                query_string = self.params.get("query", "")  # type: ignore
-
-            if query_string:
+            if search_scores:
                 # Query haystack
-                search_filter = self._get_search_query_filter(
-                    query_string, search_scores
-                )
+                search_filter = self._get_search_query_filter(model, search_scores)
         except Exception as exc:
             LOG.warning(exc)
 
-        return search_filter, search_scores
+        return search_filter

codex/views/browser/metadata.py

@@ -1,5 +1,7 @@
 """View for marking comics read and unread."""
 from copy import copy
+from types import MappingProxyType
+from typing import ClassVar
 
 from django.db.models import Count, F, IntegerField, Subquery, Value
 from drf_spectacular.utils import extend_schema
@@ -16,45 +18,53 @@ from codex.views.browser.browser_annotations import BrowserAnnotationsView
 class MetadataView(BrowserAnnotationsView):
     """Comic metadata."""
 
-    permission_classes = [IsAuthenticatedOrEnabledNonUsers]
+    permission_classes: ClassVar[list] = [IsAuthenticatedOrEnabledNonUsers]
     serializer_class = MetadataSerializer
 
     # DO NOT USE BY ITSELF. USE _get_comic_value_fields() instead.
-    _COMIC_VALUE_FIELDS = {
-        "age_rating",
-        "comments",
-        "community_rating",
-        "country",
-        "critical_rating",
-        "day",
-        "file_type",
-        "gtin",
-        "issue",
-        "issue_suffix",
-        "language",
-        "month",
-        "notes",
-        "original_format",
-        "read_ltr",
-        "scan_info",
-        "summary",
-        "web",
-        "year",
-    }
-    _ADMIN_OR_FILE_VIEW_ENABLED_COMIC_VALUE_FIELDS = {"path"}
-    _COMIC_VALUE_FIELDS_CONFLICTING = {
-        "name",
-        "updated_at",
-        "created_at",
-    }
+    _COMIC_VALUE_FIELDS = frozenset(
+        {
+            "age_rating",
+            "comments",
+            "community_rating",
+            "country",
+            "critical_rating",
+            "day",
+            "file_type",
+            "gtin",
+            "issue",
+            "issue_suffix",
+            "language",
+            "month",
+            "notes",
+            "original_format",
+            "read_ltr",
+            "scan_info",
+            "summary",
+            "web",
+            "year",
+        }
+    )
+    _ADMIN_OR_FILE_VIEW_ENABLED_COMIC_VALUE_FIELDS = frozenset({"path"})
+    _COMIC_VALUE_FIELDS_CONFLICTING = frozenset(
+        {
+            "name",
+            "updated_at",
+            "created_at",
+        }
+    )
     _COMIC_VALUE_FIELDS_CONFLICTING_PREFIX = "conflict_"
-    _COMIC_FK_FIELDS_MAP = {
-        "p": "publisher",
-        "i": "imprint",
-        "s": "series",
-        "v": "volume",
-    }
-    _COMIC_RELATED_VALUE_FIELDS = {"series__volume_count", "volume__issue_count"}
+    _COMIC_FK_FIELDS_MAP = MappingProxyType(
+        {
+            "p": "publisher",
+            "i": "imprint",
+            "s": "series",
+            "v": "volume",
+        }
+    )
+    _COMIC_RELATED_VALUE_FIELDS = frozenset(
+        {"series__volume_count", "volume__issue_count"}
+    )
     _PATH_GROUPS = ("c", "f")
     _CREATOR_RELATIONS = ("role", "person")
     _STORY_ARC_NUMBER_RELATIONS = ("story_arc",)
@@ -109,8 +119,7 @@ class MetadataView(BrowserAnnotationsView):
         if not 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
+        return self.annotate_common_aggregates(qs, self.model, {})
 
     def _annotate_values_and_fks(self, qs, simple_qs):
         """Annotate comic values and comic foreign key values."""
@@ -211,7 +220,7 @@ class MetadataView(BrowserAnnotationsView):
     def _highlight_current_group(self, obj):
         """Values for highlighting the current group."""
         obj.group = self.group
-        if not self.is_model_comic:
+        if self.model and not self.is_model_comic:
             # move the name of the group to the correct field
             group_field = self.model.__name__.lower()
             group_obj = {"pk": obj.pk, "name": obj.name}
@@ -259,7 +268,8 @@ 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.model)
+        search_scores: dict = self.get_search_scores()
+        object_filter = self.get_query_filters_without_group(self.model, search_scores)
         pk = self.kwargs["pk"]
         qs = self.model.objects.filter(object_filter, pk=pk)
 
@@ -279,8 +289,7 @@ class MetadataView(BrowserAnnotationsView):
             ) from exc
 
         m2m_intersections = self._query_m2m_intersections(simple_qs)
-        obj = self._copy_annotations_into_comic_fields(obj, m2m_intersections)
-        return obj
+        return self._copy_annotations_into_comic_fields(obj, m2m_intersections)
 
     def _is_enabled_folder_view(self):
         if self._efv_flag is None:

codex/views/cover.py

@@ -1,4 +1,6 @@
 """Comic cover thumbnail view."""
+from typing import ClassVar
+
 from django.http import HttpResponse
 from drf_spectacular.types import OpenApiTypes
 from drf_spectacular.utils import extend_schema
@@ -31,7 +33,7 @@ class WEBPRenderer(BaseRenderer):
 class CoverView(APIView, GroupACLMixin):
     """ComicCover View."""
 
-    permission_classes = [IsAuthenticatedOrEnabledNonUsers]
+    permission_classes: ClassVar[list] = [IsAuthenticatedOrEnabledNonUsers]
     renderer_classes = (WEBPRenderer,)
     content_type = "image/webp"
 

codex/views/download.py

@@ -1,5 +1,6 @@
 """Download a comic archive."""
 from pathlib import Path
+from typing import ClassVar
 
 from django.http import FileResponse, Http404
 from drf_spectacular.types import OpenApiTypes
@@ -14,7 +15,7 @@ from codex.views.mixins import GroupACLMixin
 class DownloadView(APIView, GroupACLMixin):
     """Return the comic archive file as an attachment."""
 
-    permission_classes = [IsAuthenticatedOrEnabledNonUsers]
+    permission_classes: ClassVar[list] = [IsAuthenticatedOrEnabledNonUsers]
     content_type = "application/vnd.comicbook+zip"
 
     _DOWNLOAD_SELECT_RELATED = ("series", "volume")
@@ -36,7 +37,8 @@ class DownloadView(APIView, GroupACLMixin):
             reason = f"Comic {pk} not not found."
             raise Http404(reason) from err
 
-        comic_file = Path(comic.path).open("rb")
+        # FileResponse requires file handle not be closed in this method.
+        comic_file = Path(comic.path).open("rb")  # noqa: SIM115
         return FileResponse(
             comic_file,
             as_attachment=True,

codex/views/frontend.py

@@ -1,4 +1,6 @@
 """Frontend views."""
+from typing import ClassVar
+
 from rest_framework.renderers import TemplateHTMLRenderer
 from rest_framework.response import Response
 
@@ -8,9 +10,8 @@ from codex.views.session import BrowserSessionViewBase
 class IndexView(BrowserSessionViewBase):
     """The main app."""
 
-    renderer_classes = [TemplateHTMLRenderer]
+    renderer_classes: ClassVar[list] = [TemplateHTMLRenderer]
     template_name = "index.html"
-    main_urls = {}
 
     def get(self, *args, **kwargs):
         """Get the app index page."""

codex/views/mixins.py

@@ -1,4 +1,6 @@
 """A filter for group ACLS."""
+from types import MappingProxyType
+
 from django.db.models import Q
 
 from codex.models import Comic, Folder, StoryArc
@@ -11,15 +13,17 @@ class GroupACLMixin:
     FOLDER_GROUP = "f"
     STORY_ARC_GROUP = "a"
     COMIC_GROUP = "c"
-    GROUP_RELATION = {
-        "p": "publisher",
-        "i": "imprint",
-        "s": "series",
-        "v": "volume",
-        COMIC_GROUP: "pk",
-        FOLDER_GROUP: "parent_folder",
-        STORY_ARC_GROUP: "story_arc_numbers__story_arc",
-    }
+    GROUP_RELATION = MappingProxyType(
+        {
+            "p": "publisher",
+            "i": "imprint",
+            "s": "series",
+            "v": "volume",
+            COMIC_GROUP: "pk",
+            FOLDER_GROUP: "parent_folder",
+            STORY_ARC_GROUP: "story_arc_numbers__story_arc",
+        }
+    )
 
     def get_rel_prefix(self, model):
         """Return the relation prfiex for most fields."""

codex/views/opds/authentication_v1.py

@@ -1,4 +1,6 @@
 """OPDS Authentication 1.0."""
+from types import MappingProxyType
+
 from django.contrib.staticfiles.storage import staticfiles_storage
 from django.urls import reverse_lazy
 from rest_framework.generics import GenericAPIView
@@ -12,47 +14,49 @@ class OPDSAuthentication1View(GenericAPIView):
 
     serializer_class = OPDSAuthentication1Serializer
 
-    DOC = {
-        "id": reverse_lazy("opds:authentication:v1"),
-        "title": "Codex",
-        "description": "Codex OPDS Syndication",
-        "links": [
-            {
-                "rel": "logo",
-                "href": staticfiles_storage.url("img/logo.svg"),
-                "type": "image/svg+xml",
-                "width": 512,
-                "height": 512,
-            },
-            {
-                "rel": "help",
-                "href": "https://github.com/ajslater/codex",
-                "type": "text/html",
-            },
-            {
-                "rel": "register",
-                "href": reverse_lazy("app:start"),
-                "type": "text/html",
-            },
-        ],
-        "authentication": [
-            {
-                "type": "http://opds-spec.org/auth/basic",
-                "labels": {"login": "Username", "password": "Password"},
-            },
-            {
-                # XXX Out of spec type
-                "type": "cookie",
-                "links": [
-                    {
-                        "rel": "authenticate",
-                        "href": reverse_lazy("app:start"),
-                        "type": "text/html",
-                    }
-                ],
-            },
-        ],
-    }
+    DOC = MappingProxyType(
+        {
+            "id": reverse_lazy("opds:authentication:v1"),
+            "title": "Codex",
+            "description": "Codex OPDS Syndication",
+            "links": [
+                {
+                    "rel": "logo",
+                    "href": staticfiles_storage.url("img/logo.svg"),
+                    "type": "image/svg+xml",
+                    "width": 512,
+                    "height": 512,
+                },
+                {
+                    "rel": "help",
+                    "href": "https://github.com/ajslater/codex",
+                    "type": "text/html",
+                },
+                {
+                    "rel": "register",
+                    "href": reverse_lazy("app:start"),
+                    "type": "text/html",
+                },
+            ],
+            "authentication": [
+                {
+                    "type": "http://opds-spec.org/auth/basic",
+                    "labels": {"login": "Username", "password": "Password"},
+                },
+                {
+                    # XXX Out of spec type
+                    "type": "cookie",
+                    "links": [
+                        {
+                            "rel": "authenticate",
+                            "href": reverse_lazy("app:start"),
+                            "type": "text/html",
+                        }
+                    ],
+                },
+            ],
+        }
+    )
 
     def get(self, *args, **kwargs):
         """Fill in the authentication dict."""

codex/views/opds/const.py

@@ -1,5 +1,8 @@
 """OPDS Common consts."""
 
+from collections.abc import Mapping
+from types import MappingProxyType
+
 BLANK_TITLE = "Unknown"
 FALSY = {"", "false", "0"}
 AUTHOR_ROLES = {"Writer"}
@@ -51,17 +54,21 @@ class MimeType:
     HTML = "text/html"
     AUTH_BASIC = "http://opds-spec.org/auth/basic"
     COOKIE = "cookie"
-    FILE_TYPE_MAP = {
-        "CBZ": "application/vnd.comicbook+zip",
-        "CBR": "application/vnd.comicbook+rar",
-        "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",
-    }
+    FILE_TYPE_MAP: Mapping[str, str] = MappingProxyType(
+        {
+            "CBZ": "application/vnd.comicbook+zip",
+            "CBR": "application/vnd.comicbook+rar",
+            "CBT": "application/vnd.comicbook+tar",
+            "PDF": "application/pdf",
+        }
+    )
+    SIMPLE_FILE_TYPE_MAP: Mapping[str, str] = MappingProxyType(
+        {
+            # 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/v1/entry/data.py

@@ -1,4 +1,5 @@
 """OPDS v1 Entry Data classes."""
+from collections.abc import Mapping
 from dataclasses import dataclass
 
 
@@ -20,4 +21,4 @@ class OPDS1EntryData:
     acquisition_groups: frozenset
     issue_max: int
     metadata: bool
-    mime_type_map: dict
+    mime_type_map: Mapping[str, str]

codex/views/opds/v1/facets.py

@@ -1,5 +1,6 @@
 """OPDS v1 Facets methods."""
 from dataclasses import dataclass
+from types import MappingProxyType
 
 from django.urls import reverse
 
@@ -83,7 +84,7 @@ class FacetsMixin(BrowserView):
     skip_order_facets = False
     acquisition_groups = frozenset()
     mime_type_map = MimeType.FILE_TYPE_MAP
-    obj = {}
+    obj = MappingProxyType({})
 
     def _facet(self, kwargs, facet_group, facet_title, new_query_params):
         href = reverse("opds:v1:feed", kwargs=kwargs)

codex/views/opds/v1/feed.py

@@ -1,5 +1,6 @@
 """OPDS v1 feed."""
 from datetime import datetime, timezone
+from typing import TYPE_CHECKING, Any
 
 from drf_spectacular.utils import extend_schema
 from rest_framework.authentication import BasicAuthentication, SessionAuthentication
@@ -24,6 +25,9 @@ from codex.views.opds.v1.links import (
 )
 from codex.views.template import CodexXMLTemplateView
 
+if TYPE_CHECKING:
+    from collections.abc import Mapping
+
 LOG = get_logger(__name__)
 
 
@@ -77,7 +81,10 @@ class OPDS1FeedView(CodexXMLTemplateView, LinksMixin):
         """Create the feed title."""
         result = ""
         try:
-            if browser_title := self.obj.get("browser_title"):
+            browser_title: Mapping[str, Any] = self.obj.get(
+                "browser_title"
+            )  # type: ignore
+            if browser_title:
                 parent_name = browser_title.get("parent_name", "All")
                 if not parent_name and self.kwargs.get("pk") == 0:
                     parent_name = "All"
@@ -95,7 +102,7 @@ class OPDS1FeedView(CodexXMLTemplateView, LinksMixin):
         """Hack in feed update time from cover timestamp."""
         try:
             if ts := self.obj.get("covers_timestamp"):
-                return datetime.fromtimestamp(ts, tz=timezone.utc)
+                return datetime.fromtimestamp(ts, tz=timezone.utc)  # type: ignore
         except Exception as exc:
             LOG.exception(exc)
 
@@ -120,12 +127,12 @@ class OPDS1FeedView(CodexXMLTemplateView, LinksMixin):
     def _get_entries_section(self, key, metadata):
         """Get entries by key section."""
         entries = []
-        issue_max = self.obj.get("issue_max", 0)
+        issue_max: int = self.obj.get("issue_max", 0)  # type: ignore
         data = OPDS1EntryData(
             self.acquisition_groups, issue_max, metadata, self.mime_type_map
         )
         if objs := self.obj.get(key):
-            for obj in objs:
+            for obj in objs:  # type: ignore
                 entries += [OPDS1Entry(obj, self.request.query_params, data)]
         return entries
 

codex/views/opds/v1/links.py

@@ -1,6 +1,8 @@
 """OPDS v1 Links methods."""
 from collections import defaultdict
+from collections.abc import Mapping
 from dataclasses import dataclass
+from types import MappingProxyType
 from typing import Union
 
 from comicbox.metadata.comic_json import json
@@ -20,18 +22,18 @@ LOG = get_logger(__name__)
 class TopRoutes:
     """Routes for top groups."""
 
-    PUBLISHER = {"group": "p", "pk": 0, "page": 1}
-    SERIES = {"group": "s", "pk": 0, "page": 1}
-    FOLDER = {"group": "f", "pk": 0, "page": 1}
-    ROOT = {"group": "r", "pk": 0, "page": 1}
-    STORY_ARC = {"group": "a", "pk": 0, "page": 1}
+    PUBLISHER = MappingProxyType({"group": "p", "pk": 0, "page": 1})
+    SERIES = MappingProxyType({"group": "s", "pk": 0, "page": 1})
+    FOLDER = MappingProxyType({"group": "f", "pk": 0, "page": 1})
+    ROOT = MappingProxyType({"group": "r", "pk": 0, "page": 1})
+    STORY_ARC = MappingProxyType({"group": "a", "pk": 0, "page": 1})
 
 
 @dataclass
 class TopLink:
     """A non standard root link when facets are unsupported."""
 
-    kwargs: dict
+    kwargs: Mapping
     rel: str
     mime_type: str
     query_params: defaultdict[str, Union[str, bool, int]]

codex/views/opds/v1/opensearch_v1.py

@@ -12,6 +12,6 @@ class OpenSearch1View(CodexXMLTemplateView):
     """OpenSearchView."""
 
     authentication_classes = (BasicAuthentication, SessionAuthentication)
-    permission_classes = [IsAuthenticatedOrEnabledNonUsers]
+    permission_classes = (IsAuthenticatedOrEnabledNonUsers,)
     template_name = "opds_v1/opensearch_v1.xml"
     content_type = "application/xml"

codex/views/opds/v2/feed.py

@@ -189,7 +189,8 @@ class OPDS2FeedView(PublicationMixin, TopLinksMixin):
 
         self.is_aq_feed = browser_page.get("model_group") == "c"
 
-        datetime.fromtimestamp(browser_page["covers_timestamp"], tz=timezone.utc)
+        ts: int = browser_page["covers_timestamp"]  # type: ignore
+        datetime.fromtimestamp(ts, tz=timezone.utc)
         self.num_pages = browser_page["num_pages"]
         number_of_items = browser_page["total_count"]
         title = self._title(browser_page.get("browser_title"))

codex/views/opds/v2/publications.py

@@ -1,4 +1,5 @@
 """Publication Methods for OPDS v2.0 feed."""
+from types import MappingProxyType
 from urllib.parse import quote_plus
 
 from django.contrib.staticfiles.storage import staticfiles_storage
@@ -13,18 +14,20 @@ from codex.views.opds.v2.links import HrefData, LinkData, LinksMixin
 class PublicationMixin(LinksMixin):
     """Publication Methods for OPDS 2.0 feed."""
 
-    _MD_CONTRIBUTOR_MAP = {
-        "author": AUTHOR_ROLES,
-        # "translator": {},
-        "editor": {"Editor"},
-        "artist": {"CoverArtist"},
-        # "illustrator": {},
-        "letterer": {"Letterer"},
-        "penciller": {"Penciller"},
-        "colorist": {"Colorist"},
-        "inker": {"Inker"},
-    }
-    _CONTRIBUTOR_ROLES = {x for s in _MD_CONTRIBUTOR_MAP.values() for x in s}
+    _MD_CONTRIBUTOR_MAP = MappingProxyType(
+        {
+            "author": AUTHOR_ROLES,
+            # "translator": {},
+            "editor": {"Editor"},
+            "artist": {"CoverArtist"},
+            # "illustrator": {},
+            "letterer": {"Letterer"},
+            "penciller": {"Penciller"},
+            "colorist": {"Colorist"},
+            "inker": {"Inker"},
+        }
+    )
+    _CONTRIBUTOR_ROLES = frozenset({x for s in _MD_CONTRIBUTOR_MAP.values() for x in s})
     is_opds_metadata = False
 
     def _get_big_image_link(self, obj, cover_pk):

codex/views/reader/page.py

@@ -30,7 +30,7 @@ class IgnoreClientContentNegotiation(BaseContentNegotiation):
 class ReaderPageView(BookmarkBaseView):
     """Display a comic page from the archive itself."""
 
-    X_MOZ_PRE_HEADERS = {"prefetch", "preload", "prerender", "subresource"}
+    X_MOZ_PRE_HEADERS = frozenset({"prefetch", "preload", "prerender", "subresource"})
     content_type = "image/jpeg"
     content_negotiation_class = IgnoreClientContentNegotiation  # type: ignore