codex 1.7.3a1__py3-none-any.whl → 1.7.4__py3-none-any.whl

codex/asgi.py

@@ -1,4 +1,5 @@
-"""ASGI config for codex project.
+"""
+ASGI config for codex project.
 
 It exposes the ASGI callable as a module-level variable named ``DJANGO_APPLICATION``.
 

codex/choices.py

@@ -28,12 +28,14 @@ BROWSER_ORDER_BY_CHOICES = MappingProxyType(
         "updated_at": "Updated Time",
     }
 )
-_GROUP_NAMES = {
-    "p": "Publishers",
-    "i": "Imprints",
-    "s": "Series",
-    "v": "Volumes",
-}
+_GROUP_NAMES = MappingProxyType(
+    {
+        "p": "Publishers",
+        "i": "Imprints",
+        "s": "Series",
+        "v": "Volumes",
+    }
+)
 BROWSER_TOP_GROUP_CHOICES = MappingProxyType(
     {
         **_GROUP_NAMES,
@@ -42,6 +44,7 @@ BROWSER_TOP_GROUP_CHOICES = MappingProxyType(
         "a": "Story Arcs",
     },
 )
+BROWSER_GROUP_CHOICES = MappingProxyType({**BROWSER_TOP_GROUP_CHOICES, "r": "Root"})
 VUETIFY_NULL_CODE = -1
 BROWSER_CHOICES = MappingProxyType(
     {
@@ -93,7 +96,6 @@ BROWSER_DEFAULTS = MappingProxyType(
         "order_by": "sort_name",
         "order_reverse": False,
         "q": "",
-        # "search_results_limit": 100,
         "show": _DEFAULT_SHOW,
         "top_group": "p",
         "twenty_four_hour_time": False,
@@ -391,11 +393,9 @@ ADMIN_TASK_GROUPS = MappingProxyType(
 
 def _group_task_values(groups):
     """Extract values into sorted tuple."""
-    values = []
-    for group in groups["tasks"]:
-        for item in group["tasks"]:
-            values.append(item["value"])
-    return tuple(sorted(values))
+    return tuple(
+        sorted([item["value"] for group in groups["tasks"] for item in group["tasks"]])
+    )
 
 
 ADMIN_TASKS = _group_task_values(ADMIN_TASK_GROUPS)

codex/choices_to_json.py

@@ -18,6 +18,7 @@ from codex.choices import (
     READER_DEFAULTS,
     WEBSOCKET_MESSAGES,
 )
+from codex.serializers.route import RouteSerializer
 
 _DEFAULTS = MappingProxyType(
     {"browser-choices.json": BROWSER_DEFAULTS, "reader-choices.json": READER_DEFAULTS}
@@ -68,12 +69,11 @@ def _make_json_serializable(data):
     if isinstance(data, Mapping):
         json_dict = {}
         for key, value in data.items():
-            if key == "pks":
-                # Special route serializer
-                # XXX possibly should use actual route serializer for route not just pks
-                json_dict[key] = ",".join(str(pk) for pk in sorted(value))
+            if key == "breadcrumbs":
+                json_value = tuple(RouteSerializer(dict(route)).data for route in value)
             else:
-                json_dict[_json_key(key)] = _make_json_serializable(value)
+                json_value = _make_json_serializable(value)
+            json_dict[_json_key(key)] = json_value
         return json_dict
     if isinstance(data, list | tuple | frozenset | set):
         return [_make_json_serializable(item) for item in data]
@@ -93,7 +93,7 @@ def _to_vuetify_dict(fn, data):
     return vuetify_data
 
 
-def _dump(parent_path, fn, data, vuetify=True):
+def _dump(parent_path, fn, data, vuetify):
     """Dump data to json file."""
     vuetify_data = (
         _to_vuetify_dict(fn, data) if vuetify else _make_json_serializable(data)
@@ -112,10 +112,10 @@ def main():
     parent_path = Path(parent_path)
     parent_path.mkdir(exist_ok=True)
     for fn, data in _DUMPS.items():
-        _dump(parent_path, fn, data)
+        _dump(parent_path, fn, data, vuetify=True)
 
     for fn, data in _MAP_DUMPS.items():
-        _dump(parent_path, fn, data, False)
+        _dump(parent_path, fn, data, vuetify=False)
 
 
 if __name__ == "__main__":

codex/db.py

@@ -62,7 +62,7 @@ def _backup_db_before_migration():
     """If there are migrations to do, backup the db."""
     backup_path = _get_backup_db_path(f"before-v{VERSION}")
     janitor = Janitor(LOG_QUEUE, LIBRARIAN_QUEUE)
-    janitor.backup_db(backup_path, show_status=False)
+    janitor.backup_db(show_status=False, backup_path=backup_path)
     LOG.info("Backed up database before migrations")
 
 
@@ -71,7 +71,7 @@ def _repair_db():
     if FIX_FOREIGN_KEYS:
         fix_foreign_keys()
     if INTEGRITY_CHECK:
-        integrity_check()
+        integrity_check(long=True)
     success = fts_integrity_check() if FTS_INTEGRITY_CHECK else True
     if FTS_REBUILD or not success:
         fts_rebuild()

codex/exceptions.py

@@ -1,8 +1,8 @@
 """Special Redirect Error."""
 
+from collections.abc import Mapping
 from copy import deepcopy
 from pprint import pformat
-from typing import TYPE_CHECKING
 
 from django.core.validators import EMPTY_VALUES
 from django.shortcuts import redirect
@@ -13,14 +13,10 @@ from rest_framework.status import HTTP_303_SEE_OTHER
 
 from codex.choices import DEFAULT_BROWSER_ROUTE
 from codex.logger.logging import get_logger
-from codex.serializers.fields import BreadcrumbsField
+from codex.serializers.fields.browser import BreadcrumbsField
 from codex.serializers.route import RouteSerializer
 from codex.views.util import pop_name
 
-if TYPE_CHECKING:
-    from collections.abc import Mapping
-
-
 LOG = get_logger(__name__)
 _OPDS_REDIRECT_SETTINGS_KEYS = ("order_by", "top_group")
 _REDIRECT_SETTINGS_KEYS = ("breadcrumbs", *_OPDS_REDIRECT_SETTINGS_KEYS)
@@ -71,7 +67,10 @@ class SeeOtherRedirectError(APIException):
     def _add_query_params(self, url):
         """Change OPDS settings like the frontend does with error.detail."""
         query_params = {}
-        settings: Mapping = self.detail.get("settings", {})  # type: ignore
+        if isinstance(self.detail, Mapping):
+            settings = self.detail.get("settings", {})
+        else:
+            settings = {}
         for key in _OPDS_REDIRECT_SETTINGS_KEYS:
             value = settings.get(key)
             if value not in EMPTY_VALUES:

codex/librarian/bookmark/bookmarkd.py

@@ -21,15 +21,19 @@ class BookmarkThread(AggregateMessageQueuedThread, BookmarkUpdate):
         else:
             self.log.warning(f"Unknown Bookmark task {item}")
 
+    def _send_item(self, filters, updates):
+        """Process one item."""
+        auth_filter, comic_pks = filters
+        auth_filter = dict(auth_filter)
+        self.update_bookmarks(auth_filter, comic_pks, updates, self.log)
+        self.log.debug(f"updated {auth_filter} pk__in={comic_pks}")
+
     def send_all_items(self):
         """Run the task method."""
         cleanup = set()
         for filters, updates in self.cache.items():
             try:
-                auth_filter, comic_pks = filters
-                auth_filter = dict(auth_filter)
-                self.update_bookmarks(auth_filter, comic_pks, updates, self.log)
-                self.log.debug(f"updated {auth_filter} pk__in={comic_pks}")
+                self._send_item(filters, updates)
                 cleanup.add(filters)
             except Exception:
                 self.log.exception("Updating bookmarks")

codex/librarian/bookmark/update.py

@@ -28,6 +28,35 @@ class BookmarkUpdate(GroupACLMixin):
 
     # Used by Bookmarkd and view.bookmark.
 
+    @classmethod
+    def _get_existing_bookmarks_for_update(cls, auth_filter, comic_pks, updates):
+        # Get existing bookmarks
+        query_filter = Q(**auth_filter) & Q(comic__in=comic_pks)
+        existing_bookmarks = Bookmark.objects.filter(query_filter)
+        if updates.get("page") is not None:
+            existing_bookmarks = existing_bookmarks.annotate(
+                page_count=F("comic__page_count")
+            )
+
+        update_fields = (set(updates.keys()) & _BOOKMARK_UPDATE_FIELDS) | {"updated_at"}
+        only_fields = (*update_fields, "pk")
+
+        existing_bookmarks = existing_bookmarks.only(*only_fields)
+        return existing_bookmarks, update_fields
+
+    @classmethod
+    def _prepare_bookmark_updates(cls, existing_bookmarks, updates):
+        # Prepare updates
+        update_bookmarks = []
+        for bm in existing_bookmarks:
+            cls._update_bookmarks_validate_page(bm, updates)
+            cls._update_bookmarks_validate_two_pages(bm, updates)
+            for key, value in updates.items():
+                setattr(bm, key, value)
+            bm.updated_at = Now()
+            update_bookmarks.append(bm)
+        return update_bookmarks
+
     @staticmethod
     def _update_bookmarks_validate_page(bm, updates):
         """Force bookmark page into valid range."""
@@ -44,9 +73,10 @@ class BookmarkUpdate(GroupACLMixin):
     @staticmethod
     def _update_bookmarks_validate_two_pages(bm, updates):
         """Force vertical view to not use two pages."""
-        rd = updates.get("reading_direction")
         if bm.two_pages and bool(
-            {rd, bm.reading_direction}.intersection(_VERTICAL_READING_DIRECTIONS)
+            {bm.reading_direction, updates.get("reading_direction")}.intersection(
+                _VERTICAL_READING_DIRECTIONS
+            )
         ):
             updates["two_pages"] = None
 
@@ -58,37 +88,41 @@ class BookmarkUpdate(GroupACLMixin):
         LIBRARIAN_QUEUE.put(task)
 
     @classmethod
-    def _update_bookmarks(cls, auth_filter, comic_pks, updates, user) -> int:
+    def _update_bookmarks(cls, auth_filter, comic_pks, updates) -> int:
         """Update existing bookmarks."""
         count = 0
         if not updates:
             return count
-        group_acl_filter = cls.get_group_acl_filter(Bookmark, user)
-        query_filter = group_acl_filter & Q(**auth_filter) & Q(comic__in=comic_pks)
-        existing_bookmarks = Bookmark.objects.filter(query_filter)
-        if updates.get("page") is not None:
-            existing_bookmarks = existing_bookmarks.annotate(
-                page_count=F("comic__page_count")
-            )
 
-        update_fields = set(updates.keys()) & _BOOKMARK_UPDATE_FIELDS
-        update_fields.add("updated_at")
-        only_fields = (*update_fields, "pk")
-
-        existing_bookmarks = existing_bookmarks.only(*only_fields)
-        update_bookmarks = []
-        for bm in existing_bookmarks:
-            cls._update_bookmarks_validate_page(bm, updates)
-            cls._update_bookmarks_validate_two_pages(bm, updates)
-            for key, value in updates.items():
-                setattr(bm, key, value)
-            bm.updated_at = Now()
-            update_bookmarks.append(bm)
+        existing_bookmarks, update_fields = cls._get_existing_bookmarks_for_update(
+            auth_filter, comic_pks, updates
+        )
+        update_bookmarks = cls._prepare_bookmark_updates(existing_bookmarks, updates)
         count = len(update_bookmarks)
+
+        # Bulk update
         if count:
             Bookmark.objects.bulk_update(update_bookmarks, tuple(update_fields))
         return count
 
+    @classmethod
+    def _get_comics_without_bookmarks(cls, auth_filter, comic_pks):
+        """Get comics without bookmarks."""
+        exclude = {}
+        for key, value in auth_filter.items():
+            exclude["bookmark__" + key] = value
+        query_filter = Q(pk__in=comic_pks) & ~Q(**exclude)
+        return Comic.objects.filter(query_filter).only("pk")
+
+    @classmethod
+    def _prepare_bookmark_creates(cls, create_bookmark_comics, auth_filter, updates):
+        # Prepare creates
+        create_bookmarks = []
+        for comic in create_bookmark_comics:
+            bm = Bookmark(comic=comic, **auth_filter, **updates)
+            create_bookmarks.append(bm)
+        return create_bookmarks
+
     @staticmethod
     def _create_bookmarks_validate_two_pages(updates):
         """Force vertical view to not use two pages."""
@@ -99,54 +133,54 @@ class BookmarkUpdate(GroupACLMixin):
             updates.pop("two_pages", None)
 
     @classmethod
-    def _create_bookmarks(cls, auth_filter, comic_pks, updates, user) -> int:
+    def _create_bookmarks(cls, auth_filter, comic_pks, updates) -> int:
         """Create new bookmarks for comics that don't exist yet."""
         count = 0
         cls._create_bookmarks_validate_two_pages(updates)
         if not updates:
             return count
-        create_bookmarks = []
-        group_acl_filter = cls.get_group_acl_filter(Comic, user)
-        exclude = {}
-        for key, value in auth_filter.items():
-            exclude["bookmark__" + key] = value
-        query_filter = group_acl_filter & Q(pk__in=comic_pks) & ~Q(**exclude)
-        create_bookmark_comics = Comic.objects.filter(query_filter).only("pk")
-        for comic in create_bookmark_comics:
-            bm = Bookmark(comic=comic, **auth_filter, **updates)
-            create_bookmarks.append(bm)
+
+        create_bookmark_comics = cls._get_comics_without_bookmarks(
+            auth_filter, comic_pks
+        )
+        create_bookmarks = cls._prepare_bookmark_creates(
+            create_bookmark_comics, auth_filter, updates
+        )
         count = len(create_bookmarks)
+
+        # Bulk create
         if count:
             Bookmark.objects.bulk_create(
                 create_bookmarks,
                 update_fields=tuple(_BOOKMARK_UPDATE_FIELDS),
-                unique_fields=Bookmark._meta.unique_together[0],  # type: ignore
+                unique_fields=Bookmark._meta.unique_together[0],
             )
         return count
 
     @classmethod
-    def _update_user_active(cls, user, log):
+    def _update_user_active(cls, auth_filter, log):
         """Update user active."""
         # Offline because profile gets hit rapidly in succession.
         try:
-            UserActive.objects.update_or_create(user=user)
+            user = None
+            for key, value in auth_filter.items():
+                if key == "user":
+                    user = User.objects.get(pk=value)
+                    if user:
+                        UserActive.objects.update_or_create(user=user)
+                break
+        except User.DoesNotExist:
+            pass
         except Exception as exc:
-            reason = f"update user activity {exc}"
+            reason = f"Update user activity {exc}"
             log.warning(reason)
 
     @classmethod
     def update_bookmarks(cls, auth_filter, comic_pks, updates, log):
         """Update a user bookmark."""
-        user = None
-        for key, value in auth_filter.items():
-            if key == "user":
-                user = User.objects.get(pk=value)
-            break
-
-        count = cls._update_bookmarks(auth_filter, comic_pks, updates, user)
-        count += cls._create_bookmarks(auth_filter, comic_pks, updates, user)
-        if user:
-            cls._update_user_active(user, log)
+        count = cls._update_bookmarks(auth_filter, comic_pks, updates)
+        count += cls._create_bookmarks(auth_filter, comic_pks, updates)
+        cls._update_user_active(auth_filter, log)
         if count:
             uid = next(iter(auth_filter.values()))
             cls._notify_library_changed(uid)

codex/librarian/covers/create.py

@@ -32,7 +32,7 @@ class CoverCreateThread(QueuedThread, CoverPathMixin):
             with Image.open(image_io) as cover_image:
                 cover_image.thumbnail(
                     _THUMBNAIL_SIZE,
-                    Image.Resampling.LANCZOS,  # type: ignore
+                    Image.Resampling.LANCZOS,
                     reducing_gap=3.0,
                 )
                 cover_image.save(cover_thumb_buffer, "WEBP", method=6)
@@ -41,7 +41,8 @@ class CoverCreateThread(QueuedThread, CoverPathMixin):
 
     @classmethod
     def _get_comic_cover_image(cls, comic_path):
-        """Create comic cover if none exists.
+        """
+        Create comic cover if none exists.
 
         Return image thumb data or path to missing file thumb.
         """
@@ -59,8 +60,9 @@ class CoverCreateThread(QueuedThread, CoverPathMixin):
             return f.read()
 
     @classmethod
-    def create_cover_from_path(cls, pk, cover_path, log, librarian_queue, custom=False):
-        """Create cover for path.
+    def create_cover_from_path(cls, pk, cover_path, log, librarian_queue, custom):
+        """
+        Create cover for path.
 
         Called from views/cover.
         """
@@ -95,7 +97,7 @@ class CoverCreateThread(QueuedThread, CoverPathMixin):
             # zero length file is code for missing.
             cover_path.touch()
 
-    def _bulk_create_comic_covers(self, pks, custom=False):
+    def _bulk_create_comic_covers(self, pks, custom):
         """Create bulk comic covers."""
         num_comics = len(pks)
         if not num_comics:
@@ -115,7 +117,7 @@ class CoverCreateThread(QueuedThread, CoverPathMixin):
                 else:
                     # bulk contributor creates covers inline
                     data = self.create_cover_from_path(
-                        pk, cover_path, self.log, self.librarian_queue
+                        pk, cover_path, self.log, self.librarian_queue, custom=False
                     )
                     if data:
                         data.close()
@@ -134,6 +136,6 @@ class CoverCreateThread(QueuedThread, CoverPathMixin):
     def create_all_covers(self):
         """Create all covers for all libraries."""
         pks = CustomCover.objects.values_list("pk", flat=True)
-        self._bulk_create_comic_covers(pks, True)
+        self._bulk_create_comic_covers(pks, custom=True)
         pks = Comic.objects.values_list("pk", flat=True)
-        self._bulk_create_comic_covers(pks, False)
+        self._bulk_create_comic_covers(pks, custom=False)

codex/librarian/covers/path.py

@@ -21,20 +21,21 @@ class CoverPathMixin:
         """Translate an integer into an efficient filesystem path."""
         fnv = fnv1a_32(bytes(str(pk).zfill(cls._ZFILL), "utf-8"))
         hex_str = format(fnv, f"0{cls._ZFILL}x")
-        parts = []
-        for i in range(0, len(hex_str), cls._PATH_STEP):
-            parts.append(hex_str[i : i + cls._PATH_STEP])
+        parts = [
+            hex_str[i : i + cls._PATH_STEP]
+            for i in range(0, len(hex_str), cls._PATH_STEP)
+        ]
         return Path("/".join(parts))
 
     @classmethod
-    def get_cover_path(cls, pk, custom=False):
+    def get_cover_path(cls, pk, custom):
         """Get cover path for comic pk."""
         cover_path = cls._hex_path(pk)
         root = cls.CUSTOM_COVERS_ROOT if custom else cls.COVERS_ROOT
         return root / cover_path.with_suffix(".webp")
 
     @classmethod
-    def get_cover_paths(cls, pks, custom=False):
+    def get_cover_paths(cls, pks, custom):
         """Get cover paths for many comic pks."""
         cover_paths = set()
         for pk in pks:

codex/librarian/covers/purge.py

@@ -67,7 +67,7 @@ class CoverPurgeThread(CoverCreateThread):
             self.log.info("Removed entire comic cover cache.")
             shutil.rmtree(self.CUSTOM_COVERS_ROOT)
             self.log.info("Removed entire custom cover cache.")
-        except Exception as exc:
+        except OSError as exc:
             self.log.warning(exc)
         librarian_queue.put(LIBRARY_CHANGED_TASK)
 
@@ -77,7 +77,7 @@ class CoverPurgeThread(CoverCreateThread):
             self.log.debug(f"Removing covers from missing {name}.")
             self.status_controller.start_many(self._CLEANUP_STATUS_MAP)
             pks = cover_class.objects.all().values_list("pk", flat=True)
-            db_cover_paths = self.get_cover_paths(pks)
+            db_cover_paths = self.get_cover_paths(pks, custom=False)
 
             orphan_cover_paths = set()
             for root, _, filenames in os.walk(cover_root):

codex/librarian/importer/aggregate.py

@@ -222,10 +222,10 @@ class AggregateMetadataImporter(ExtractMetadataImporter):
         if self.task.force_import_metadata:
             import_metadata = True
         else:
-            key = AdminFlag.FlagChoices.IMPORT_METADATA.value  # type: ignore
+            key = AdminFlag.FlagChoices.IMPORT_METADATA.value
             import_metadata = AdminFlag.objects.get(key=key).on
         if not import_metadata:
-            self.log.warn("Admin flag set to NOT import metadata.")
+            self.log.warning("Admin flag set to NOT import metadata.")
 
         # Init metadata, extract and aggregate
         self.metadata[MDS] = {}

codex/librarian/importer/cache.py

@@ -73,7 +73,6 @@ class CacheUpdateImporter(InitImporter):
         try:
             log_list = []
             for model in GROUP_MODELS:
-                # self.log.debug(f"Updating timestamps for {model.__name__}s...")
                 count = self._update_group_model(
                     force_update_group_map, model, start_time, log_list
                 )
@@ -85,9 +84,7 @@ class CacheUpdateImporter(InitImporter):
 
             if total_count:
                 groups_log = ", ".join(log_list)
-                self.log.info(  # type: ignore
-                    f"Updated timestamps for {groups_log}."
-                )
+                self.log.info(f"Updated timestamps for {groups_log}.")
                 self.changed += total_count
         finally:
             self.status_controller.finish(status)

codex/librarian/importer/create_comics.py

@@ -78,7 +78,7 @@ class CreateComicsImporter(LinkComicsImporter):
             Comic.objects.bulk_update(update_comics, BULK_UPDATE_COMIC_FIELDS)
             count = len(update_comics)
 
-            self._remove_covers(comic_pks, False)  # type: ignore
+            self._remove_covers(comic_pks, custom=False)
             self.log.debug(f"Purging covers for {len(comic_pks)} updated comics.")
             if count:
                 self.log.info(f"Updated {count} comics.")
@@ -126,7 +126,7 @@ class CreateComicsImporter(LinkComicsImporter):
                     create_comics,
                     update_conflicts=True,
                     update_fields=BULK_CREATE_COMIC_FIELDS,
-                    unique_fields=Comic._meta.unique_together[0],  # type: ignore
+                    unique_fields=Comic._meta.unique_together[0],
                 )
                 count = len(create_comics)
                 if count:

codex/librarian/importer/create_covers.py

@@ -43,7 +43,7 @@ class CreateCoversImporter(CreateComicsImporter):
             if LINK_COVER_PKS not in self.metadata:
                 self.metadata[LINK_COVER_PKS] = set()
             self.metadata[LINK_COVER_PKS].update(update_cover_pks)
-            self._remove_covers(update_cover_pks, custom=True)  # type: ignore
+            self._remove_covers(update_cover_pks, custom=True)
             count = len(update_covers)
             if status:
                 status.add_complete(count)

codex/librarian/importer/create_fks.py

@@ -1,4 +1,5 @@
-"""Create all missing comic foreign keys for an import.
+"""
+Create all missing comic foreign keys for an import.
 
 So we may safely create the comics next.
 """
@@ -189,7 +190,7 @@ class CreateForeignKeysImporter(CreateCoversImporter):
             create_folders,
             update_conflicts=True,
             update_fields=BULK_UPDATE_FOLDER_FIELDS,
-            unique_fields=Folder._meta.unique_together[0],  # type: ignore
+            unique_fields=Folder._meta.unique_together[0],
         )
         count = len(create_folders)
         status.add_complete(count)
@@ -296,7 +297,7 @@ class CreateForeignKeysImporter(CreateCoversImporter):
             create_objs,
             update_conflicts=True,
             update_fields=CREATE_DICT_UPDATE_FIELDS[model],
-            unique_fields=model._meta.unique_together[0],  # type: ignore
+            unique_fields=model._meta.unique_together[0],
         )
         count = len(create_objs)
         if count:

codex/librarian/importer/deleted.py

@@ -13,7 +13,7 @@ from codex.status import Status
 class DeletedImporter(CacheUpdateImporter):
     """Clean up database methods."""
 
-    def _remove_covers(self, delete_pks, custom=False):
+    def _remove_covers(self, delete_pks, custom: bool):
         task = CoverRemoveTask(delete_pks, custom)
         self.librarian_queue.put(task)
 
@@ -34,7 +34,7 @@ class DeletedImporter(CacheUpdateImporter):
         )
         folders.delete()
 
-        self._remove_covers(delete_comic_pks)
+        self._remove_covers(delete_comic_pks, custom=False)
 
         count = len(delete_comic_pks)
         if count:
@@ -96,7 +96,7 @@ class DeletedImporter(CacheUpdateImporter):
         delete_comic_pks = frozenset(delete_qs.values_list("pk", flat=True))
         delete_qs.delete()
 
-        self._remove_covers(delete_comic_pks)
+        self._remove_covers(delete_comic_pks, custom=False)
 
         count = len(delete_comic_pks)
         if count: