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

codex/views/browser/choices.py

@@ -1,11 +1,21 @@
 """View for marking comics read and unread."""
 import pycountry
 from caseconverter import snakecase
+from django.db.models import QuerySet
 from drf_spectacular.utils import extend_schema
 from rest_framework.response import Response
 
 from codex.logger.logging import get_logger
-from codex.models import Comic, CreatorPerson
+from codex.models import (
+    Comic,
+    CreatorPerson,
+    Folder,
+    Imprint,
+    Publisher,
+    Series,
+    StoryArc,
+    Volume,
+)
 from codex.serializers.browser import (
     BrowserChoicesSerializer,
     BrowserFilterChoicesSerializer,
@@ -22,23 +32,37 @@ class BrowserChoicesViewBase(BrowserBaseView):
 
     permission_classes = [IsAuthenticatedOrEnabledNonUsers]
 
-    CREATORS_PERSON_REL = "creators__person"
-    NULL_NAMED_ROW = {"pk": -1, "name": "_none_"}
+    _CREATORS_PERSON_REL = "creators__person"
+    _STORY_ARC_REL = "story_arc_numbers__story_arc"
+    _NULL_NAMED_ROW = {"pk": -1, "name": "_none_"}
+    _BACK_REL_MAP = {CreatorPerson: "creator__", StoryArc: "storyarcnumber__"}
+    _REL_MAP = {
+        Publisher: "publisher",
+        Imprint: "imprint",
+        Series: "series",
+        Volume: "volume",
+        Comic: "pk",
+        Folder: "parent_folder",
+        StoryArc: "story_arc_numbers__story_arc",
+    }
 
     @staticmethod
-    def get_field_choices_query(field_name, comic_qs):
+    def get_field_choices_query(comic_qs, field_name):
         """Get distinct values for the field."""
-        return comic_qs.values_list(field_name, flat=True).distinct()
+        return (
+            comic_qs.exclude(**{field_name: None})
+            .values_list(field_name, flat=True)
+            .distinct()
+        )
 
-    @classmethod
-    def get_m2m_field_query(cls, rel, comic_qs, model):
+    def get_m2m_field_query(self, model, comic_qs: QuerySet):
         """Get distinct m2m value objects for the relation."""
-        comic_rel = "creator__comic" if rel == cls.CREATORS_PERSON_REL else "comic"
+        back_rel = self._BACK_REL_MAP.get(model, "")
+        back_rel += "comic__"
+        back_rel += self._REL_MAP[self.model]
+        back_rel += "__in"
         return (
-            model.objects.filter(**{f"{comic_rel}__in": comic_qs})
-            .prefetch_related(comic_rel)
-            .values("pk", "name")
-            .distinct()
+            model.objects.filter(**{back_rel: comic_qs}).values("pk", "name").distinct()
         )
 
     @staticmethod
@@ -46,12 +70,14 @@ class BrowserChoicesViewBase(BrowserBaseView):
         """Get if null values exists for an m2m field."""
         return comic_qs.filter(**{f"{rel}__isnull": True}).exists()
 
-    @classmethod
-    def _get_rel_and_model(cls, field_name):
+    def _get_rel_and_model(self, field_name):
         """Return the relation and model for the field name."""
-        if field_name == cls.CREATOR_PERSON_UI_FIELD:
-            rel = cls.CREATORS_PERSON_REL
+        if field_name == self.CREATOR_PERSON_UI_FIELD:
+            rel = self._CREATORS_PERSON_REL
             model = CreatorPerson
+        elif field_name == self.STORY_ARC_UI_FIELD:
+            rel = self._STORY_ARC_REL
+            model = StoryArc
         else:
             remote_field = getattr(
                 Comic._meta.get_field(field_name), "remote_field", None
@@ -59,12 +85,21 @@ class BrowserChoicesViewBase(BrowserBaseView):
             rel = field_name
             model = remote_field.model if remote_field else None
 
+        rel = self.rel_prefix + rel
+
         return rel, model
 
     def get_object(self):
         """Get the comic subquery use for the choices."""
-        object_filter, _ = self.get_query_filters(True, True)
-        return Comic.objects.filter(object_filter)
+        object_filter, _ = self.get_query_filters(self.model, True)
+        return self.model.objects.filter(object_filter)
+
+    def _set_model(self):
+        """Set the model to query."""
+        group = self.kwargs["group"]
+        if group == self.ROOT_GROUP:
+            group = self.params.get("top_group", "p")
+        self.model = self.GROUP_MODEL_MAP[group]
 
 
 class BrowserChoicesAvailableView(BrowserChoicesViewBase):
@@ -72,23 +107,20 @@ class BrowserChoicesAvailableView(BrowserChoicesViewBase):
 
     serializer_class = BrowserFilterChoicesSerializer
 
-    CREATORS_PERSON_REL = "creators__person"
-
     @classmethod
-    def _get_field_choices_count(cls, field_name, comic_qs):
+    def _get_field_choices_count(cls, comic_qs, field_name):
         """Create a pk:name object for fields without tables."""
-        return cls.get_field_choices_query(field_name, comic_qs).count()
+        return cls.get_field_choices_query(comic_qs, field_name).count()
 
-    @classmethod
-    def _get_m2m_field_choices_count(cls, rel, comic_qs, model):
+    def _get_m2m_field_choices_count(self, model, comic_qs, rel):
         """Get choices with nulls where there are nulls."""
-        count = cls.get_m2m_field_query(rel, comic_qs, model).count()
+        count = self.get_m2m_field_query(model, comic_qs).count()
 
         # Detect if there are null choices.
         # Regretabbly with another query, but doing a forward query
         # on the comic above restricts all results to only the filtered
         # rows. :(
-        if cls.does_m2m_null_exist(comic_qs, rel):
+        if self.does_m2m_null_exist(comic_qs, rel):
             count += 1
 
         return count
@@ -97,16 +129,21 @@ class BrowserChoicesAvailableView(BrowserChoicesViewBase):
     def get(self, *args, **kwargs):
         """Return all choices with more than one choice."""
         self.parse_params()
+        self._set_model()
+        self.set_rel_prefix(self.model)
         comic_qs = self.get_object()
 
         data = {}
         for field_name in self.serializer_class().get_fields():  # type: ignore
+            if field_name == "story_arcs" and self.model == StoryArc:
+                # don't allow filtering on story arc in story arc view.
+                continue
             rel, m2m_model = self._get_rel_and_model(field_name)
 
             if m2m_model:
-                count = self._get_m2m_field_choices_count(rel, comic_qs, m2m_model)
+                count = self._get_m2m_field_choices_count(m2m_model, comic_qs, rel)
             else:
-                count = self._get_field_choices_count(rel, comic_qs)
+                count = self._get_field_choices_count(comic_qs, rel)
 
             filters = self.params.get("filters", {})
             data[field_name] = count > 1 or field_name in filters
@@ -120,10 +157,9 @@ class BrowserChoicesView(BrowserChoicesViewBase):
 
     serializer_class = BrowserChoicesSerializer
 
-    @classmethod
-    def _get_field_choices(cls, field_name, comic_qs):
+    def _get_field_choices(self, comic_qs, field_name):
         """Create a pk:name object for fields without tables."""
-        qs = cls.get_field_choices_query(field_name, comic_qs)
+        qs = self.get_field_choices_query(comic_qs, field_name)
 
         if field_name == "country":
             lookup = pycountry.countries
@@ -139,18 +175,17 @@ class BrowserChoicesView(BrowserChoicesViewBase):
 
         return choices
 
-    @classmethod
-    def _get_m2m_field_choices(cls, rel, comic_qs, model):
+    def _get_m2m_field_choices(self, model, comic_qs, rel):
         """Get choices with nulls where there are nulls."""
-        qs = cls.get_m2m_field_query(rel, comic_qs, model)
+        qs = self.get_m2m_field_query(model, comic_qs)
 
         # Detect if there are null choices.
         # Regretabbly with another query, but doing a forward query
         # on the comic above restrcts all results to only the filtered
         # rows. :(
-        if cls.does_m2m_null_exist(comic_qs, rel):
+        if self.does_m2m_null_exist(comic_qs, rel):
             choices = list(qs)
-            choices.append(cls.NULL_NAMED_ROW)
+            choices.append(self._NULL_NAMED_ROW)
         else:
             choices = qs
         return choices
@@ -159,6 +194,8 @@ class BrowserChoicesView(BrowserChoicesViewBase):
     def get(self, *args, **kwargs):
         """Return all choices with more than one choice."""
         self.parse_params()
+        self._set_model()
+        self.set_rel_prefix(self.model)
 
         field_name = snakecase(self.kwargs["field_name"])
 
@@ -166,9 +203,9 @@ class BrowserChoicesView(BrowserChoicesViewBase):
 
         comic_qs = self.get_object()
         if m2m_model:
-            choices = self._get_m2m_field_choices(rel, comic_qs, m2m_model)
+            choices = self._get_m2m_field_choices(m2m_model, comic_qs, rel)
         else:
-            choices = self._get_field_choices(rel, comic_qs)
+            choices = self._get_field_choices(comic_qs, rel)
 
         serializer = self.get_serializer(choices, many=True)
         return Response(serializer.data)

codex/views/browser/filters/bookmark.py

@@ -9,12 +9,10 @@ class BookmarkFilterMixin:
 
     _BOOKMARK_FILTERS = frozenset(set(CHOICES["bookmarkFilter"].keys()) - {"ALL"})
 
-    def get_bm_rel(self, is_model_comic):
+    def get_bm_rel(self, model):
         """Create bookmark relation."""
-        bm_rel = "bookmark"
-        if not is_model_comic:
-            bm_rel = "comic__" + bm_rel
-        return bm_rel
+        rel_prefix = self.get_rel_prefix(model)  # type: ignore
+        return rel_prefix + "bookmark"
 
     def _get_my_bookmark_filter(self, bm_rel):
         """Get a filter for my session or user defined bookmarks."""
@@ -27,12 +25,11 @@ class BookmarkFilterMixin:
             }
         return Q(**my_bookmarks_kwargs)
 
-    def get_bookmark_filter(self, is_model_comic, choice):
+    def get_bookmark_filter(self, model):
         """Build bookmark query."""
-        if choice is None:
-            choice = self.params["filters"].get("bookmark", "ALL")  # type: ignore
+        choice = self.params["filters"].get("bookmark", "ALL")  # type: ignore
         if choice in self._BOOKMARK_FILTERS:
-            bm_rel = self.get_bm_rel(is_model_comic)
+            bm_rel = self.get_bm_rel(model)
             my_bookmark_filter = self._get_my_bookmark_filter(bm_rel)
             if choice in ("UNREAD", "IN_PROGRESS"):
                 my_not_finished_filter = my_bookmark_filter & Q(

codex/views/browser/filters/field.py

@@ -7,18 +7,21 @@ from codex.views.session import BrowserSessionViewBase
 class ComicFieldFilter(BrowserSessionViewBase):
     """Comic field filters."""
 
-    def _filter_by_comic_field(self, field, is_model_comic):
+    def _filter_by_comic_field(self, field):
         """Filter by a comic any2many attribute."""
         filter_list = self.params["filters"].get(field)  # type: ignore
         filter_query = Q()
         if not filter_list:
             return filter_query
-        query_prefix = "" if is_model_comic else "comic__"
 
         if field == self.CREATOR_PERSON_UI_FIELD:
-            rel = f"{query_prefix}creators__person"
+            rel = "creators__person"
+        elif field == self.STORY_ARC_UI_FIELD:
+            rel = "storyarcnumber__story_arc"
         else:
-            rel = f"{query_prefix}{field}"
+            rel = field
+
+        rel = self.rel_prefix + rel  # type: ignore
 
         for index, val in enumerate(filter_list):
             # None values in a list don't work right so test for them separately
@@ -29,9 +32,9 @@ class ComicFieldFilter(BrowserSessionViewBase):
             filter_query |= Q(**{f"{rel}__in": filter_list})
         return filter_query
 
-    def get_comic_field_filter(self, is_model_comic):
+    def get_comic_field_filter(self):
         """Filter the comics based on the form filters."""
         comic_field_filter = Q()
         for attribute in self.FILTER_ATTRIBUTES:
-            comic_field_filter &= self._filter_by_comic_field(attribute, is_model_comic)
+            comic_field_filter &= self._filter_by_comic_field(attribute)
         return comic_field_filter

codex/views/browser/filters/group.py

@@ -7,35 +7,20 @@ from codex.views.mixins import GroupACLMixin
 class GroupFilterMixin(GroupACLMixin):
     """Group Filters."""
 
-    def _get_folders_filter(self):
-        """Get a filter for ALL parent folders not just immediate one."""
-        pk = self.kwargs.get("pk")  # type: ignore
-        return Q(folders__in=[pk]) if pk else Q()
-
-    def _get_browser_group_filter(self):
-        """Get the objects we'll be displaying."""
-        # Get the instances that are children of the group_instance
-        # And the filtered comics that are children of the group_instance
-        group_filter = Q()
-        pk = self.kwargs.get("pk")  # type: ignore
-        group = self.kwargs.get("group")  # type: ignore
-        if pk or group == self.FOLDER_GROUP:
-            if not pk:
-                pk = None
-            group_relation = self.GROUP_RELATION[group]
-            group_filter |= Q(**{group_relation: pk})
-
-        return group_filter
-
     def get_group_filter(self, choices):
         """Get filter for the displayed group."""
-        is_folder_view = self.kwargs.get("group") == self.FOLDER_GROUP  # type: ignore
-        if is_folder_view and choices:
-            # Choice view needs to get all descendant comic attributes
-            # So filter by all the folders
-            group_filter = self._get_folders_filter()
+        pk = self.kwargs.get("pk")  # type: ignore
+        group = self.kwargs.get("group")  # type: ignore
+        if pk:
+            group_relation = "comic__" if choices else ""
+            if choices and group == self.FOLDER_GROUP:
+                group_relation += "folders"
+            else:
+                group_relation += self.GROUP_RELATION[group]
+            group_filter = Q(**{group_relation: pk})
+        elif group == self.FOLDER_GROUP:
+            group_filter = Q(parent_folder=None)
         else:
-            # The browser filter is the same for all views
-            group_filter = self._get_browser_group_filter()
+            group_filter = Q()
 
         return group_filter

codex/views/browser/filters/search.py

@@ -23,19 +23,14 @@ class SearchFilterMixin:
             LOG.warning("While searching:")
             LOG.exception(exc)
 
-    def _get_search_query_filter(self, text, is_model_comic, search_scores):
+    def _get_search_query_filter(self, text, search_scores):
         """Get the search filter and scores."""
-        # Get search scores
+        rel = self.rel_prefix + "pk__in"  # type: ignore
         self._get_search_scores(text, search_scores)
-
-        # Create query
-        prefix = ""
-        if not is_model_comic:
-            prefix = "comic__"
-        query_dict = {f"{prefix}pk__in": search_scores.keys()}
+        query_dict = {rel: search_scores.keys()}
         return Q(**query_dict)
 
-    def get_search_filter(self, is_model_comic):
+    def get_search_filter(self):
         """Preparse search, search and return the filter and scores."""
         search_filter = Q()
         search_scores = {}
@@ -48,7 +43,7 @@ class SearchFilterMixin:
             if query_string:
                 # Query haystack
                 search_filter = self._get_search_query_filter(
-                    query_string, is_model_comic, search_scores
+                    query_string, search_scores
                 )
         except Exception as exc:
             LOG.warning(exc)

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"