codex 1.7.15__py3-none-any.whl → 1.8.0a2__py3-none-any.whl

codex/librarian/scribe/importer/create/covers.py

@@ -0,0 +1,123 @@
+"""Create Custom Covers."""
+
+from django.core.exceptions import ObjectDoesNotExist
+from django.db.models.functions.datetime import Now
+
+from codex.librarian.scribe.importer.const import (
+    CLASS_CUSTOM_COVER_GROUP_MAP,
+    CREATE_COVERS,
+    CUSTOM_COVER_UPDATE_FIELDS,
+    LINK_COVER_PKS,
+    UPDATE_COVERS,
+)
+from codex.librarian.scribe.importer.create.comics import CreateComicsImporter
+from codex.librarian.scribe.importer.statii.create import (
+    ImporterCreateCoversStatus,
+    ImporterUpdateCoversStatus,
+)
+from codex.librarian.scribe.importer.statii.link import ImporterLinkCoversStatus
+from codex.models import CustomCover
+
+
+class CreateCoversImporter(CreateComicsImporter):
+    """Create Custom Covers."""
+
+    @staticmethod
+    def add_custom_cover_to_group(group_class, obj):
+        """If a custom cover exists for this group, add it."""
+        group = CLASS_CUSTOM_COVER_GROUP_MAP.get(group_class)
+        if not group:
+            # Normal, volume doesn't link to covers
+            return
+        try:
+            cover = CustomCover.objects.filter(group=group, sort_name=obj.sort_name)[0]
+            obj.custom_cover = cover
+        except (IndexError, ObjectDoesNotExist):
+            pass
+
+    def update_custom_covers(self):
+        """Update Custom Covers."""
+        count = 0
+        status = ImporterUpdateCoversStatus(0)
+        try:
+            update_covers_qs = self.metadata.pop(UPDATE_COVERS, None)
+            if not update_covers_qs:
+                self.status_controller.finish(status)
+                return count
+            update_covers_count = update_covers_qs.count()
+            if not update_covers_count:
+                self.status_controller.finish(status)
+                return count
+            status.total = update_covers_count
+            self.status_controller.start(status)
+
+            update_covers = []
+            for cover in update_covers_qs.only(*CUSTOM_COVER_UPDATE_FIELDS):
+                cover.updated_at = Now()
+                cover.presave()
+                update_covers.append(cover)
+
+            if update_covers:
+                CustomCover.objects.bulk_update(
+                    update_covers, CUSTOM_COVER_UPDATE_FIELDS
+                )
+                update_cover_pks = update_covers_qs.values_list("pk", flat=True)
+                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)
+                count = len(update_covers)
+                if status:
+                    status.increment_complete(count)
+
+                link_covers_status = ImporterLinkCoversStatus(
+                    0,
+                    len(self.metadata[LINK_COVER_PKS]),
+                )
+                self.status_controller.update(link_covers_status, notify=False)
+        finally:
+            self.status_controller.finish(status)
+        return count
+
+    def create_custom_covers(self):
+        """Create Custom Covers."""
+        count = 0
+        create_cover_paths = self.metadata.pop(CREATE_COVERS, ())
+        num_create_cover_paths = len(create_cover_paths)
+        status = ImporterCreateCoversStatus(0, num_create_cover_paths)
+        try:
+            if not num_create_cover_paths:
+                self.status_controller.finish(status)
+                return count
+
+            self.status_controller.start(status)
+
+            create_covers = []
+            for path in create_cover_paths:
+                cover = CustomCover(library=self.library, path=path)
+                cover.presave()
+                create_covers.append(cover)
+
+            if create_covers:
+                objs = CustomCover.objects.bulk_create(
+                    create_covers,
+                    update_conflicts=True,
+                    update_fields=("path", "stat"),
+                    unique_fields=CustomCover._meta.unique_together[0],
+                )
+                created_pks = frozenset(obj.pk for obj in objs)
+                if LINK_COVER_PKS not in self.metadata:
+                    self.metadata[LINK_COVER_PKS] = set()
+                self.metadata[LINK_COVER_PKS].update(created_pks)
+                count = len(created_pks)
+                if status:
+                    status.increment_complete(count)
+
+                link_covers_status = ImporterLinkCoversStatus(
+                    0, len(self.metadata[LINK_COVER_PKS])
+                )
+                self.status_controller.update(link_covers_status, notify=False)
+
+        finally:
+            self.status_controller.finish(status)
+        return count

codex/librarian/scribe/importer/create/folders.py

@@ -0,0 +1,98 @@
+"""Create missing folder foreign keys for an import."""
+
+from pathlib import Path
+
+from codex.librarian.scribe.importer.const import BULK_UPDATE_FOLDER_FIELDS
+from codex.librarian.scribe.importer.create.covers import CreateCoversImporter
+from codex.librarian.status import Status
+from codex.models import Folder
+
+
+class CreateForeignKeysFolderImporter(CreateCoversImporter):
+    """Methods for creating foreign keys."""
+
+    def _get_parent_folder(self, path: Path):
+        parent = None
+        if str(path) == self.library.path:
+            return parent
+        parent_path = str(path.parent)
+        try:
+            parent = Folder.objects.get(path=parent_path)
+        except Folder.DoesNotExist:
+            if path.parent != Path(self.library.path):
+                reason = (
+                    f"Can't find parent folder {parent_path} for {path} in library"
+                    " {self.library.path}"
+                )
+                self.log.warning(reason)
+        return parent
+
+    def _bulk_folders_create_add_folder(self, path: Path, create_folders):
+        """Add one folder to the create list."""
+        parent_folder = self._get_parent_folder(path)
+        folder = Folder(
+            library=self.library,
+            path=str(path),
+            name=path.name,
+            parent_folder=parent_folder,
+        )
+        folder.presave()
+        self.add_custom_cover_to_group(Folder, folder)
+        create_folders.append(folder)
+
+    def _bulk_folders_create_depth_level(self, paths, status: Status):
+        """Create a depth level of folders."""
+        create_folders = []
+        for path in sorted(paths):
+            self._bulk_folders_create_add_folder(path, create_folders)
+        Folder.objects.bulk_create(
+            create_folders,
+            update_conflicts=True,
+            update_fields=BULK_UPDATE_FOLDER_FIELDS,
+            unique_fields=Folder._meta.unique_together[0],
+        )
+        count = len(create_folders)
+        status.increment_complete(count)
+        self.status_controller.update(status)
+        return count
+
+    def bulk_folders_create(self, folder_paths: frozenset, status) -> int:
+        """Create folders breadth first."""
+        count = 0
+        if not folder_paths:
+            return count
+        # group folder paths by depth
+        folder_path_dict = {}
+        for path_strs in folder_paths:
+            for path_str in path_strs:
+                path = Path(path_str)
+                path_length = len(path.parts)
+                if path_length not in folder_path_dict:
+                    folder_path_dict[path_length] = set()
+                folder_path_dict[path_length].add(path)
+
+        # create each depth level first to ensure we can assign parents
+        for depth_level in sorted(folder_path_dict):
+            paths = sorted(folder_path_dict[depth_level])
+            level_count = self._bulk_folders_create_depth_level(paths, status)
+            count += level_count
+            self.log.debug(
+                f"Created {level_count} Folders at depth level {depth_level}"
+            )
+
+        self.status_controller.update(status)
+        return count
+
+    def bulk_folders_update(self, folder_paths: frozenset, status) -> int:
+        """Update existing folders."""
+        # Is this really moved?
+        count = 0
+        if not folder_paths:
+            return count
+
+        folders = Folder.objects.filter(library=self.library, path__in=folder_paths)
+        for folder in folders:
+            folder.save()
+
+        self.status_controller.update(status)
+        return count

codex/librarian/scribe/importer/create/foreign_keys.py

@@ -0,0 +1,253 @@
+"""
+Create all missing comic many to many objects for an import.
+
+So we may safely create the comics next.
+"""
+
+from collections.abc import Mapping
+from itertools import chain
+
+from codex.librarian.scribe.importer.const import (
+    COMPLEX_M2M_MODELS,
+    CREATE_FKS,
+    FTS_CREATED_M2MS,
+    FTS_UPDATED_M2MS,
+    GROUP_MODEL_COUNT_FIELDS,
+    MODEL_REL_MAP,
+    TOTAL,
+    UPDATE_FKS,
+)
+from codex.librarian.scribe.importer.create.const import (
+    CUSTOM_COVER_MODELS,
+    DEFAULT_NON_NULL_CHARFIELD_NAMES,
+    GROUP_BASE_FIELDS,
+    GROUP_BASE_MODELS,
+    MODEL_CREATE_ARGS_MAP,
+    NON_NULL_CHARFIELD_NAMES,
+    ORDERED_CREATE_MODELS,
+)
+from codex.librarian.scribe.importer.create.folders import (
+    CreateForeignKeysFolderImporter,
+)
+from codex.librarian.scribe.importer.statii.create import (
+    ImporterCreateTagsStatus,
+    ImporterUpdateTagsStatus,
+)
+from codex.librarian.status import Status
+from codex.models.base import BaseModel
+from codex.models.groups import Folder
+from codex.models.named import Universe
+
+
+class CreateForeignKeysCreateUpdateImporter(CreateForeignKeysFolderImporter):
+    """Methods for creating foreign keys."""
+
+    @staticmethod
+    def _get_create_update_args(
+        model: type[BaseModel],
+        key_args_map: Mapping,
+        update_args_map: Mapping,
+        values_tuple: tuple,
+    ):
+        """Create key args and update args."""
+        key_args = {}
+        update_args = {}
+        num_keys = len(key_args_map)
+        for index, (field_name, field_model) in enumerate(
+            chain(key_args_map.items(), update_args_map.items())
+        ):
+            value = values_tuple[index]
+            if field_model and value is not None:
+                key_rels = MODEL_REL_MAP[field_model][0]
+                if field_model in GROUP_MODEL_COUNT_FIELDS and index < num_keys:
+                    value = values_tuple[: index + 1]
+                elif not isinstance(value, tuple):
+                    value = (value,)
+                sub_model_key_args = dict(zip(key_rels, value, strict=True))
+                value = field_model.objects.get(**sub_model_key_args)
+            non_null_charfield_names = NON_NULL_CHARFIELD_NAMES.get(
+                model, DEFAULT_NON_NULL_CHARFIELD_NAMES
+            )
+            if value is None and field_name in non_null_charfield_names:
+                value = ""
+            arg_map = key_args if index < num_keys else update_args
+            arg_map[field_name] = value
+        return key_args, update_args
+
+    def _add_custom_cover(self, model, obj):
+        self.add_custom_cover_to_group(model, obj)
+
+    def _finish_create_update(self, model, objs, status: Status):
+        count = len(objs)
+        if count:
+            vnp = model._meta.verbose_name_plural
+            title = vnp.title() if vnp else model._meta.verbose_name
+            self.log.info(f"Created {count} {title}.")
+        status.increment_complete(count)
+        self.status_controller.update(status)
+
+    def _bulk_create_models(
+        self,
+        model: type[BaseModel],
+        status,
+    ):
+        """Bulk create a dict type m2m model."""
+        count = 0
+        create_tuples = self.metadata[CREATE_FKS].pop(model, None)
+        if not create_tuples:
+            return count
+        status.subtitle = model._meta.verbose_name_plural
+        self.status_controller.update(status)
+        key_args_map, update_args_map = MODEL_CREATE_ARGS_MAP[model]
+        create_objs = []
+        create_tuples = sorted(create_tuples, key=str)
+        created_fts_values = {}
+        for values_tuple in create_tuples:
+            key_args, update_args = self._get_create_update_args(
+                model, key_args_map, update_args_map, values_tuple
+            )
+            obj = model(**key_args, **update_args)
+            obj.presave()
+            if model in CUSTOM_COVER_MODELS:
+                self._add_custom_cover(model, obj)
+            create_objs.append(obj)
+            if model == Universe and update_args:
+                fts_update_values = tuple(
+                    value for value in update_args.values() if isinstance(value, str)
+                )
+                created_fts_values[tuple(key_args.values())] = fts_update_values
+
+        if created_fts_values:
+            field_name = model.__name__.lower() + "s"
+            self.metadata[FTS_CREATED_M2MS][field_name] = created_fts_values
+
+        update_fields = tuple(key_args_map.keys()) + tuple(update_args_map.keys())
+        if model in GROUP_BASE_MODELS:
+            update_fields += GROUP_BASE_FIELDS
+
+        count = len(create_objs)
+        model.objects.bulk_create(
+            create_objs,
+            update_conflicts=True,
+            update_fields=update_fields,
+            unique_fields=model._meta.unique_together[0],
+        )
+        self._finish_create_update(model, create_objs, status)
+        return count
+
+    def bulk_create_all_models(self, status):
+        """
+        Bulk create all dict type m2m models.
+
+        Done in three phases for dependency order
+        """
+        count = 0
+        complex_models = []
+        # These come first in this order
+        for model in ORDERED_CREATE_MODELS:
+            count += self._bulk_create_models(
+                model,
+                status,
+            )
+        for model in tuple(self.metadata[CREATE_FKS]):
+            if model in COMPLEX_M2M_MODELS:
+                # These must come last
+                complex_models.append(model)
+            else:
+                count += self._bulk_create_models(
+                    model,
+                    status,
+                )
+        for model in complex_models:
+            count += self._bulk_create_models(
+                model,
+                status,
+            )
+        return count
+
+    def _bulk_update_models(self, model: type[BaseModel], status):
+        count = 0
+        update_tuples = self.metadata[UPDATE_FKS].pop(model, None)
+        if not update_tuples:
+            return count
+        status.subtitle = model._meta.verbose_name_plural
+        self.status_controller.update(status)
+        key_args_map, update_args_map = MODEL_CREATE_ARGS_MAP[model]
+        update_objs = []
+        update_tuples = sorted(update_tuples, key=lambda t: str(t))
+        fts_update_pks = set()
+        for values_tuple in update_tuples:
+            key_args, update_args = self._get_create_update_args(
+                model, key_args_map, update_args_map, values_tuple
+            )
+            obj = model.objects.get(**key_args)
+            for key, value in update_args.items():
+                setattr(obj, key, value)
+            obj.presave()
+            if model in CUSTOM_COVER_MODELS:
+                self._add_custom_cover(model, obj)
+            update_objs.append(obj)
+            # Generic code, but really it's only universe
+            # if tuple(
+            #    value for value in update_args.values() if isinstance(value, str)
+            # ):
+            if model == Universe:
+                fts_update_pks.add(obj.pk)
+
+        if fts_update_pks:
+            field_name = model.__name__.lower() + "s"
+            self.metadata[FTS_UPDATED_M2MS][field_name] = fts_update_pks
+
+        update_fields = tuple(update_args_map.keys())
+        if model in GROUP_BASE_MODELS:
+            update_fields += GROUP_BASE_FIELDS
+
+        count = len(update_objs)
+        model.objects.bulk_update(update_objs, fields=update_fields)
+        self._finish_create_update(model, update_objs, status)
+        return count
+
+    def bulk_update_all_models(self, status):
+        """Bulk update all complex models."""
+        count = 0
+        for model in tuple(self.metadata[UPDATE_FKS].keys()):
+            count += self._bulk_update_models(model, status)
+        return count
+
+    def create_all_fks(self) -> int:
+        """Bulk create all foreign keys."""
+        count = 0
+        fkc = self.metadata.get(CREATE_FKS, {})
+        create_status = ImporterCreateTagsStatus(0, fkc.pop(TOTAL, 0))
+        try:
+            self.metadata[FTS_CREATED_M2MS] = {}
+            if not fkc:
+                return count
+            self.status_controller.start(create_status)
+            count += self.bulk_folders_create(
+                fkc.pop(Folder, frozenset()), create_status
+            )
+            count += self.bulk_create_all_models(create_status)
+        finally:
+            self.metadata.pop(CREATE_FKS, None)
+            self.status_controller.finish(create_status)
+        return count
+
+    def update_all_fks(self) -> int:
+        """Bulk update all foreign keys."""
+        count = 0
+        fku = self.metadata.get(UPDATE_FKS, {})
+        update_status = ImporterUpdateTagsStatus(0, fku.pop(TOTAL, 0))
+        try:
+            self.metadata[FTS_UPDATED_M2MS] = {}
+            if not fku:
+                return count
+            self.status_controller.start(update_status)
+            count += self.bulk_folders_update(
+                fku.pop(Folder, frozenset()), update_status
+            )
+            count += self.bulk_update_all_models(update_status)
+        finally:
+            self.metadata.pop(UPDATE_FKS, None)
+            self.status_controller.finish(update_status)
+        return count

codex/librarian/scribe/importer/create/link_fks.py

@@ -0,0 +1,73 @@
+"""Bulk update m2m fields foreign keys."""
+
+from contextlib import suppress
+from pathlib import Path
+from typing import TYPE_CHECKING
+
+from comicbox.schemas.comicbox import PROTAGONIST_KEY
+
+from codex.librarian.scribe.importer.const import (
+    LINK_FKS,
+    PARENT_FOLDER_FIELD_NAME,
+    PROTAGONIST_FIELD_MODEL_MAP,
+    VOLUME_FIELD_NAME,
+)
+from codex.librarian.scribe.importer.link import LinkComicsImporter
+from codex.librarian.scribe.importer.link.const import (
+    DEFAULT_KEY_RELS,
+    GROUP_KEY_RELS,
+)
+from codex.models import Folder
+from codex.models.comic import Comic
+
+if TYPE_CHECKING:
+    from codex.models.base import BaseModel
+
+
+class CreateForeignKeyLinksImporter(LinkComicsImporter):
+    """Link comics methods."""
+
+    def _get_comic_folder_fk_link(self, md, subkey: int | str, path: str):
+        parent_path = str(Path(path).parent)
+        md[PARENT_FOLDER_FIELD_NAME] = Folder.objects.get(path=parent_path)
+        self.add_links_to_fts(
+            subkey,
+            PARENT_FOLDER_FIELD_NAME,
+            (parent_path,),
+        )
+
+    def _get_comic_protagonist_fk_link(self, md, link_fks: dict[str, tuple]):
+        """Protagonist does not create. Only links."""
+        if name := link_fks.pop(PROTAGONIST_KEY, None):
+            name = name[0]
+        for field_name, protagonist_model in PROTAGONIST_FIELD_MODEL_MAP.items():
+            value = None
+            if name:
+                with suppress(protagonist_model.DoesNotExist):
+                    value = protagonist_model.objects.get(name=name)
+            md[field_name] = value
+
+    def _get_comic_simple_fk_links(
+        self, md, subkey: int | str, link_fks: dict[str, tuple]
+    ):
+        for field_name in tuple(link_fks.keys()):
+            model: type[BaseModel] = Comic._meta.get_field(field_name).related_model  # pyright: ignore[reportAssignmentType]
+            key_rels = GROUP_KEY_RELS.get(model, DEFAULT_KEY_RELS)
+            values = link_fks.pop(field_name)
+            filter_dict = dict(zip(key_rels, values, strict=True))
+            md[field_name] = model.objects.get(**filter_dict)
+            if field_name != VOLUME_FIELD_NAME:
+                self.add_links_to_fts(
+                    subkey,
+                    field_name,
+                    (values[-1],),
+                )
+
+    def get_comic_fk_links(self, subkey: str | int, path: str):
+        """Get links for all foreign keys for creating and updating."""
+        md = {}
+        self._get_comic_folder_fk_link(md, subkey, path)
+        if link_fks := self.metadata[LINK_FKS].pop(path, {}):
+            self._get_comic_protagonist_fk_link(md, link_fks)
+            self._get_comic_simple_fk_links(md, subkey, link_fks)
+        return md

codex/librarian/scribe/importer/delete/__init__.py

@@ -0,0 +1,28 @@
+"""Clean up the database after moves or imports."""
+
+from codex.librarian.scribe.importer.delete.folders import DeletedFoldersImporter
+from codex.librarian.scribe.timestamp_update import TimestampUpdater
+
+
+class DeletedImporter(DeletedFoldersImporter):
+    """Delete database objects methods."""
+
+    def delete(self):
+        """Delete files and folders."""
+        if self.abort_event.is_set():
+            return
+        self.counts.folders_deleted += self.bulk_folders_deleted()
+        if self.abort_event.is_set():
+            return
+        self.counts.comics_deleted, deleted_comic_groups = self.bulk_comics_deleted()
+        if self.abort_event.is_set():
+            return
+        self.counts.covers_deleted = self.bulk_covers_deleted()
+        if self.abort_event.is_set():
+            return
+        timestamp_updater = TimestampUpdater(
+            self.log, self.librarian_queue, self.db_write_lock
+        )
+        timestamp_updater.update_library_groups(
+            self.library, self.start_time, deleted_comic_groups
+        )

codex/librarian/scribe/importer/delete/comics.py

@@ -0,0 +1,68 @@
+"""Delete comics methods."""
+
+from codex.librarian.scribe.importer.const import ALL_COMIC_GROUP_FIELD_NAMES
+from codex.librarian.scribe.importer.delete.covers import DeletedCoversImporter
+from codex.librarian.scribe.importer.statii.delete import ImporterRemoveComicsStatus
+from codex.models import Comic, Folder, StoryArc
+from codex.settings import MAX_CHUNK_SIZE
+
+
+class DeletedComicsImporter(DeletedCoversImporter):
+    """Delete comics methods."""
+
+    @staticmethod
+    def _init_deleted_comic_groups():
+        """Init deleted_comic_groups, used later even if no deletes."""
+        deleted_comic_groups = {}
+        for field_name in ALL_COMIC_GROUP_FIELD_NAMES:
+            if field_name == "story_arc_numbers":
+                related_model = StoryArc
+            else:
+                related_model = Comic._meta.get_field(field_name).related_model
+            deleted_comic_groups[related_model] = set()
+        return deleted_comic_groups
+
+    @classmethod
+    def _populate_deleted_comic_groups(cls, delete_qs):
+        """Populate changed groups for cover timestamp updater."""
+        deleted_comic_groups = cls._init_deleted_comic_groups()
+        comics_deleted_qs = delete_qs.only(
+            *ALL_COMIC_GROUP_FIELD_NAMES
+        ).prefetch_related("story_arc_numbers__story_arc")
+        for comic in comics_deleted_qs.iterator(chunk_size=MAX_CHUNK_SIZE):
+            for field_name in ALL_COMIC_GROUP_FIELD_NAMES:
+                if field_name == "story_arc_numbers":
+                    for san in comic.story_arc_numbers.select_related("story_arc").only(
+                        "story_arc"
+                    ):
+                        deleted_comic_groups[StoryArc].add(san.story_arc.pk)
+                elif field_name == "folders":
+                    for folder in comic.folders.only("pk"):
+                        deleted_comic_groups[Folder].add(folder.pk)
+                else:
+                    related_model = comic._meta.get_field(field_name).related_model
+                    related_id = getattr(comic, field_name).pk
+                    deleted_comic_groups[related_model].add(related_id)
+        return deleted_comic_groups
+
+    def bulk_comics_deleted(self, **kwargs) -> tuple[int, dict]:
+        """Bulk delete comics found missing from the filesystem."""
+        status = ImporterRemoveComicsStatus(0, len(self.task.files_deleted))
+        try:
+            if not self.task.files_deleted:
+                return 0, {}
+            self.status_controller.start(status)
+            delete_qs = Comic.objects.filter(
+                library=self.library, path__in=self.task.files_deleted
+            )
+            self.task.files_deleted = frozenset()
+
+            deleted_comic_groups = self._populate_deleted_comic_groups(delete_qs)
+
+            delete_comic_pks = frozenset(delete_qs.values_list("pk", flat=True))
+            count, _ = delete_qs.delete()
+
+            self.remove_covers(delete_comic_pks, custom=False)
+        finally:
+            self.status_controller.finish(status)
+        return count, deleted_comic_groups

codex/librarian/scribe/importer/delete/covers.py

@@ -0,0 +1,35 @@
+"""Clean up covers from the db."""
+
+from codex.librarian.covers.tasks import CoverRemoveTask
+from codex.librarian.scribe.importer.search import SearchIndexImporter
+from codex.librarian.scribe.importer.statii.delete import ImporterRemoveCoversStatus
+from codex.models.paths import CustomCover
+
+
+class DeletedCoversImporter(SearchIndexImporter):
+    """Clean up covers from the db."""
+
+    def remove_covers(self, delete_pks, *, custom: bool):
+        """Queue a remove covers task."""
+        task = CoverRemoveTask(delete_pks, custom)
+        self.librarian_queue.put(task)
+
+    def bulk_covers_deleted(self, **kwargs):
+        """Bulk delete comics found missing from the filesystem."""
+        status = ImporterRemoveCoversStatus(0, len(self.task.covers_deleted))
+        try:
+            if not self.task.covers_deleted:
+                return 0
+            self.status_controller.start(status)
+            covers = CustomCover.objects.filter(
+                library=self.library, path__in=self.task.covers_deleted
+            )
+            self.task.covers_deleted = frozenset()
+            delete_cover_pks = frozenset(covers.values_list("pk", flat=True))
+            count, _ = covers.delete()
+
+            self.remove_covers(delete_cover_pks, custom=True)
+        finally:
+            self.status_controller.finish(status)
+
+        return count