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

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

@@ -0,0 +1,70 @@
+"""Link Covers."""
+
+from pathlib import Path
+
+from codex.librarian.scribe.importer.const import (
+    CLASS_CUSTOM_COVER_GROUP_MAP,
+    LINK_COVER_PKS,
+)
+from codex.librarian.scribe.importer.failed_imports import FailedImportsImporter
+from codex.librarian.scribe.importer.statii.link import ImporterLinkCoversStatus
+from codex.models import CustomCover, Folder
+
+
+class LinkCoversImporter(FailedImportsImporter):
+    """Link Covers methods."""
+
+    def _link_custom_cover_prepare(self, cover, model_map):
+        """Prepare one cover in the model map for bulk update."""
+        if cover.library and cover.library.covers_only:
+            model = CLASS_CUSTOM_COVER_GROUP_MAP.inverse.get(cover.group)
+            if not model:
+                self.log.warning(f"Custom Cover model not found for {cover.path}")
+                return
+            group_filter = {"sort_name": cover.sort_name}
+        else:
+            model = Folder
+            path = str(Path(cover.path).parent)
+            group_filter = {"path": path}
+        qs = model.objects.filter(**group_filter).exclude(custom_cover=cover)
+        if not qs.exists():
+            return
+
+        if model not in model_map:
+            model_map[model] = []
+
+        for obj in qs.iterator():
+            obj.custom_cover = cover
+            model_map[model].append(obj)
+
+    def _link_custom_cover_group(self, model, objs, status):
+        """Bulk link a group to it's custom covers."""
+        if not objs:
+            return
+        model.objects.bulk_update(objs, ["custom_cover"])
+        status.complete += len(objs)
+        self.status_controller.update(status)
+
+    def link_custom_covers(self):
+        """Link Custom Covers to Groups."""
+        link_cover_pks = self.metadata.get(LINK_COVER_PKS, {})
+        num_link_cover_pks = len(link_cover_pks)
+        status = ImporterLinkCoversStatus(0, num_link_cover_pks)
+        try:
+            if not num_link_cover_pks:
+                return 0
+            self.status_controller.start(status)
+            # Aggregate objs to update for each group model.
+            model_map = {}
+            covers = CustomCover.objects.filter(pk__in=link_cover_pks).only(
+                "library", "path"
+            )
+            for cover in covers:
+                self._link_custom_cover_prepare(cover, model_map)
+
+            # Bulk update each model type
+            for model, objs in model_map.items():
+                self._link_custom_cover_group(model, objs, status)
+        finally:
+            self.status_controller.finish(status)
+        return status.complete

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

@@ -0,0 +1,106 @@
+"""Delete stale m2ms."""
+
+from typing import TYPE_CHECKING
+
+from django.db.models import ManyToManyField, Q
+
+from codex.librarian.scribe.importer.const import (
+    DELETE_M2MS,
+    FTS_EXISTING_M2MS,
+    FTS_UPDATE,
+)
+from codex.librarian.scribe.importer.link.prepare import LinkComicsImporterPrepare
+from codex.models import Comic
+from codex.models.base import BaseModel
+from codex.settings import FILTER_BATCH_SIZE
+
+if TYPE_CHECKING:
+    from django.db.models.fields.related import ManyToManyRel
+
+
+class LinkImporterDelete(LinkComicsImporterPrepare):
+    """Delete stale m2ms."""
+
+    @staticmethod
+    def get_through_model(field: ManyToManyField) -> type[BaseModel]:
+        """Get the through model for a m2m field."""
+        remote_field: ManyToManyRel = field.remote_field  # pyright: ignore[reportAssignmentType]
+        return remote_field.through  #  pyright: ignore[reportReturnType]
+
+    def _delete_m2m_field_batch(
+        self,
+        column_name: str,
+        through_model: type[BaseModel],
+        batch_rows: tuple,
+        comic_ids: set[int],
+    ):
+        del_filter = Q()
+        for row in batch_rows:
+            comic_id, model_id = row
+            del_filter_dict = {"comic_id": comic_id, column_name: model_id}
+            del_filter |= Q(**del_filter_dict)
+            comic_ids.add(comic_id)
+
+        qs = through_model.objects.filter(del_filter)
+        count, _ = qs.delete()
+        return count
+
+    def _delete_m2m_fts_entries(self, field_name: str, comic_ids: set[int]):
+        fts_field_name = (
+            "story_arcs" if field_name == "story_arc_numbers" else field_name
+        )
+        for comic_id in comic_ids:
+            if not self.metadata[FTS_UPDATE].get(comic_id, {}).get(
+                fts_field_name
+            ) and not self.metadata[FTS_EXISTING_M2MS].get(comic_id, {}).get(
+                fts_field_name
+            ):
+                self.add_links_to_fts(comic_id, fts_field_name, ())
+
+    def delete_m2m_field(self, field_name: str, delete_m2ms: dict, status):
+        """Delete one comic field's m2m relations."""
+        total_field_count = 0
+        rows = tuple(delete_m2ms.pop(field_name, ()))
+        num_rows = len(rows)
+        if not num_rows:
+            return total_field_count
+        status.subtitle = f"Delete stale {field_name} links"
+        self.status_controller.update(status)
+        field: ManyToManyField = Comic._meta.get_field(field_name)  # pyright:ignore[reportAssignmentType]
+        related_model = field.related_model
+        table_name = related_model._meta.db_table
+        column_name = table_name.removeprefix("codex_") + "_id"
+        through_model = self.get_through_model(field)
+        comic_ids = set()
+
+        start = 0
+        while start < num_rows:
+            end = start + FILTER_BATCH_SIZE
+            batch_rows = rows[start:end]
+            count = self._delete_m2m_field_batch(
+                column_name, through_model, batch_rows, comic_ids
+            )
+            status.complete += count
+            total_field_count += count
+            if count:
+                self.log.info(
+                    f"Deleted {total_field_count}/{num_rows} stale {field_name} relations for altered comics.",
+                )
+
+            self.status_controller.update(status)
+            start += FILTER_BATCH_SIZE
+
+        self._delete_m2m_fts_entries(field_name, comic_ids)
+
+        return total_field_count
+
+    def delete_m2ms(self, status):
+        """Delete old missing m2ms."""
+        delete_m2ms = self.metadata.pop(DELETE_M2MS, {})
+
+        del_total = 0
+        for field_name in sorted(delete_m2ms.keys()):
+            del_total += self.delete_m2m_field(field_name, delete_m2ms, status)
+        if del_total:
+            self.log.info(f"Deleted {del_total} stale relations for altered comics.")
+        return del_total

codex/librarian/scribe/importer/link/many_to_many.py

@@ -0,0 +1,88 @@
+"""Link Comics M2M fields."""
+
+from typing import TYPE_CHECKING
+
+from codex.librarian.scribe.importer.const import (
+    DELETE_M2MS,
+    LINK_M2MS,
+)
+from codex.librarian.scribe.importer.link.sum import LinkSumImporter
+from codex.librarian.scribe.importer.statii.link import ImporterLinkTagsStatus
+from codex.librarian.status import Status
+from codex.models import Comic
+
+if TYPE_CHECKING:
+    from django.db.models import ManyToManyField
+
+
+class LinkManyToManyImporter(LinkSumImporter):
+    """Link Comics M2M fields."""
+
+    def link_comic_m2m_field(self, field_name, m2m_links, status: Status):
+        """
+        Recreate an m2m field for a set of comics.
+
+        Since we can't bulk_update or bulk_create m2m fields use a trick.
+        bulk_create() on the through table:
+        https://stackoverflow.com/questions/6996176/how-to-create-an-object-for-a-django-model-with-a-many-to-many-field/10116452#10116452
+        https://docs.djangoproject.com/en/dev/ref/models/fields/#django.db.models.ManyToManyField.through
+        """
+        status.subtitle = field_name
+        self.status_controller.update(status)
+        field: ManyToManyField = Comic._meta.get_field(field_name)  # pyright: ignore[reportAssignmentType]
+        through_model = self.get_through_model(field)
+        through_field_id_name = field.related_model.__name__.lower() + "_id"
+
+        tms = []
+        for comic_id, model_ids in m2m_links.items():
+            for model_id in model_ids:
+                args = {"comic_id": comic_id, through_field_id_name: model_id}
+                tm = through_model(**args)
+                tms.append(tm)
+
+        count = len(tms)
+        if count:
+            update_fields = ("comic_id", through_field_id_name)
+            through_model.objects.bulk_create(
+                tms,
+                update_conflicts=True,
+                update_fields=update_fields,
+                unique_fields=update_fields,
+            )
+            status.increment_complete(count)
+            self.status_controller.update(status)
+        return count
+
+    def link_comic_m2m_fields(self):
+        """Combine query and bulk link into a batch."""
+        link_total = self.sum_ops(DELETE_M2MS) + self.sum_path_ops(LINK_M2MS)
+        status = ImporterLinkTagsStatus(0, link_total)
+        try:
+            if not link_total:
+                self.status_controller.finish(status)
+                return link_total
+
+            self.status_controller.start(status)
+            del_total = self.delete_m2ms(status)
+
+            # get ids for through model writing.
+            all_m2m_links = self.link_prepare_m2m_links(status)
+
+            num_links = sum(
+                len(m2m_links.values()) for m2m_links in all_m2m_links.values()
+            )
+            status.total = num_links
+
+            created_total = 0
+            for field_name, m2m_links in all_m2m_links.items():
+                if self.abort_event.is_set():
+                    return created_total + del_total
+                try:
+                    created_total += self.link_comic_m2m_field(
+                        field_name, m2m_links, status
+                    )
+                except Exception:
+                    self.log.exception(f"Error recreating m2m field: {field_name}")
+        finally:
+            self.status_controller.finish(status)
+        return created_total + del_total

codex/librarian/scribe/importer/link/prepare.py

@@ -0,0 +1,132 @@
+"""Prepare links with database objects."""
+
+from collections.abc import Callable, Mapping
+from typing import TYPE_CHECKING
+
+from django.db.models.query import Q
+
+from codex.librarian.scribe.importer.const import (
+    FIELD_NAME_KEYS_REL_MAP,
+    FOLDERS_FIELD_NAME,
+    FTS_CREATED_M2MS,
+    IDENTIFIERS_FIELD_NAME,
+    LINK_M2MS,
+)
+from codex.librarian.scribe.importer.link.const import COMPLEX_MODEL_FIELD_NAMES
+from codex.librarian.scribe.importer.link.covers import (
+    LinkCoversImporter,
+)
+from codex.models import Comic
+from codex.util import flatten
+
+if TYPE_CHECKING:
+    from codex.models.base import BaseModel
+
+
+class LinkComicsImporterPrepare(LinkCoversImporter):
+    """Prepare links with database objects."""
+
+    @staticmethod
+    def _get_link_folders_filter(_field_name, values_set):
+        """Get the ids of all folders to link."""
+        folder_paths = frozenset(flatten(values_set))
+        return Q(path__in=folder_paths)
+
+    @staticmethod
+    def _get_link_complex_model_filter(field_name, values_set):
+        """Get the ids of all dict style objects to link."""
+        rels = FIELD_NAME_KEYS_REL_MAP[field_name]
+        dict_filter = Q()
+        for values in values_set:
+            rel_complex = dict(zip(rels, values, strict=False))
+            dict_filter |= Q(**rel_complex)
+        return dict_filter
+
+    def _add_complex_link_to_fts(
+        self, comic_pk: int, field_name: str, values: frozenset
+    ):
+        if field_name == IDENTIFIERS_FIELD_NAME:
+            # sources extracton must come before identifiers is minified
+            sources = tuple(subvalues[0] for subvalues in values)
+            self.add_links_to_fts(comic_pk, "sources", sources)
+
+        field_name, fts_values = self.minify_complex_link_to_fts_tuple(
+            field_name, values
+        )
+        self.add_links_to_fts(comic_pk, field_name, fts_values)
+
+    def _link_prepare_complex_m2ms(
+        self,
+        all_m2m_links: dict,
+        md: dict,
+        comic_pk: int,
+        field_name: str,
+        link_filter_method: Callable,
+    ):
+        """Prepare special m2m for linking."""
+        values = md.pop(field_name, None)
+        if not values:
+            return
+        self._add_complex_link_to_fts(comic_pk, field_name, values)
+        model: type[BaseModel] = Comic._meta.get_field(field_name).related_model  # pyright: ignore[reportAssignmentType]
+        m2m_filter = link_filter_method(field_name, values)
+        pks = model.objects.filter(m2m_filter).values_list("pk", flat=True).distinct()
+        if result := tuple(pks):
+            if field_name not in all_m2m_links:
+                all_m2m_links[field_name] = {}
+            all_m2m_links[field_name][comic_pk] = result
+
+    def _link_prepare_named_m2ms(
+        self,
+        all_m2m_links: dict,
+        comic_pk: int,
+        field_name: str,
+        names: tuple[str, ...] | frozenset[str],
+    ):
+        """Set the ids of all named m2m fields into the comic dict."""
+        model = Comic._meta.get_field(field_name).related_model
+        if model is None:
+            self.log.error(f"No related class found for Comic.{field_name}")
+            return
+        self.add_links_to_fts(comic_pk, field_name, tuple(names))
+        names = frozenset(name[0] for name in names)
+        pks = (
+            model.objects.filter(name__in=names).values_list("pk", flat=True).distinct()
+        )
+        if result := tuple(pks):
+            if field_name not in all_m2m_links:
+                all_m2m_links[field_name] = {}
+            all_m2m_links[field_name][comic_pk] = result
+
+    def link_prepare_m2m_links(self, status) -> Mapping:
+        """Get the complete m2m field data to create."""
+        status.subtitle = "Preparing..."
+        self.status_controller.update(status)
+        all_m2m_links = {}
+        comic_paths = tuple(self.metadata.get(LINK_M2MS, {}).keys())
+        if not comic_paths:
+            return all_m2m_links
+
+        comics = Comic.objects.filter(path__in=comic_paths).values_list("pk", "path")
+        for comic_pk, comic_path in comics:
+            md = self.metadata[LINK_M2MS][comic_path]
+            self._link_prepare_complex_m2ms(
+                all_m2m_links,
+                md,
+                comic_pk,
+                FOLDERS_FIELD_NAME,
+                self._get_link_folders_filter,
+            )
+            for field_name in COMPLEX_MODEL_FIELD_NAMES:
+                self._link_prepare_complex_m2ms(
+                    all_m2m_links,
+                    md,
+                    comic_pk,
+                    field_name,
+                    self._get_link_complex_model_filter,
+                )
+            for field, names in md.items():
+                self._link_prepare_named_m2ms(all_m2m_links, comic_pk, field, names)
+        self.metadata.pop(LINK_M2MS)
+        self.metadata.pop(FTS_CREATED_M2MS)
+        return all_m2m_links

codex/librarian/scribe/importer/link/sum.py

@@ -0,0 +1,19 @@
+"""Total methods for updating statii."""
+
+from codex.librarian.scribe.importer.link.delete import LinkImporterDelete
+
+
+class LinkSumImporter(LinkImporterDelete):
+    """Total methods for updating statii."""
+
+    def sum_path_ops(self, key):
+        """Sum all the operations for the key."""
+        count = 0
+        for fields in self.metadata[key].values():
+            for ops in fields.values():
+                count += len(ops)
+        return count
+
+    def sum_ops(self, key):
+        """Sum all the operations for the key."""
+        return sum(len(ops) for ops in self.metadata[key].values())

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

@@ -0,0 +1,52 @@
+"""Bulk import and move comics and folders."""
+
+from pathlib import Path
+
+from django.db.models.functions import Now
+
+from codex.librarian.scribe.importer.const import BULK_UPDATE_FOLDER_MODIFIED_FIELDS
+from codex.librarian.scribe.importer.moved.folders import MovedFoldersImporter
+from codex.librarian.scribe.importer.statii.create import ImporterUpdateTagsStatus
+from codex.models import Folder
+
+
+class MovedImporter(MovedFoldersImporter):
+    """Methods for moving comics and folders."""
+
+    def _bulk_folders_modified(self):
+        """Update folders stat and nothing else."""
+        num_dirs_modified = len(self.task.dirs_modified)
+        if not num_dirs_modified:
+            return 0
+        status = ImporterUpdateTagsStatus(None, num_dirs_modified)
+        status.subtitle = "Folders"
+        self.status_controller.start(status)
+
+        folders = Folder.objects.filter(
+            library=self.library, path__in=self.task.dirs_modified
+        ).only("stat", "updated_at")
+        self.task.dirs_modified = frozenset()
+        update_folders = []
+        for folder in folders.iterator():
+            if Path(folder.path).exists():
+                folder.updated_at = Now()
+                folder.presave()
+                update_folders.append(folder)
+        Folder.objects.bulk_update(
+            update_folders, fields=BULK_UPDATE_FOLDER_MODIFIED_FIELDS
+        )
+        count = len(update_folders)
+        level = "INFO" if count else "DEBUG"
+        self.log.log(level, f"Modified {count} folders")
+        status.complete = status.total = None
+        self.status_controller.update(status)
+        return count
+
+    def move_and_modify_dirs(self):
+        """Move files and dirs and modify dirs."""
+        # It would be nice to move folders instead of recreating them but it would require
+        # an inode map from the snapshots to do correctly.
+        self.counts.folders_moved += self.bulk_folders_moved()
+        self.counts.comics_moved += self.bulk_comics_moved()
+        self.counts.covers_moved += self.bulk_covers_moved()
+        self.counts.folders += self._bulk_folders_modified()

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

@@ -0,0 +1,125 @@
+"""Bulk import and move comics."""
+
+from pathlib import Path
+
+from django.db.models.functions import Now
+
+from codex.librarian.scribe.importer.const import (
+    CREATE_FKS,
+    FOLDERS_FIELD_NAME,
+    MOVED_BULK_COMIC_UPDATE_FIELDS,
+    PARENT_FOLDER_FIELD_NAME,
+    PATH_FIELD_NAME,
+)
+from codex.librarian.scribe.importer.read import ReadMetadataImporter
+from codex.librarian.scribe.importer.statii.create import ImporterCreateTagsStatus
+from codex.librarian.scribe.importer.statii.moved import ImporterMoveComicsStatus
+from codex.librarian.scribe.importer.statii.query import ImporterQueryMissingTagsStatus
+from codex.models import Comic, Folder
+
+
+class MovedComicsImporter(ReadMetadataImporter):
+    """Methods for moving comics and folders."""
+
+    def _bulk_comics_moved_ensure_folders(self):
+        """Ensure folders we're moving to exist."""
+        dest_comic_paths = self.task.files_moved.values()
+        dest_comic_paths = self.get_all_library_relative_paths(dest_comic_paths)
+        num_dest_comic_paths = len(dest_comic_paths)
+        if not num_dest_comic_paths:
+            return
+        # Not sending statues to the controller for now.
+        status = ImporterQueryMissingTagsStatus()
+        if CREATE_FKS not in self.metadata:
+            self.metadata[CREATE_FKS] = {}
+        proposed_values_map = {(path,): set() for path in dest_comic_paths}
+        self.query_missing_models(
+            Folder,
+            proposed_values_map,
+            status,
+        )
+        create_folder_paths = self.metadata[CREATE_FKS].pop(Folder, {})
+        count = len(create_folder_paths)
+        if not count:
+            return
+        status = ImporterCreateTagsStatus(0, count)
+        self.log.debug(
+            "Creating {count} folders for {num_dest_comic_paths} moved comics."
+        )
+        self.bulk_folders_create(create_folder_paths, status)
+        self.status_controller.finish(status)
+
+    def _prepare_moved_comic(
+        self, comic, folder_m2m_links, updated_comics, del_folder_rows
+    ):
+        """Prepare one comic for bulk update."""
+        try:
+            new_path = self.task.files_moved[comic.path]
+            old_folder_pks = frozenset(folder.pk for folder in comic.folders.all())
+            comic.path = new_path
+            new_path = Path(new_path)
+            comic.parent_folder = Folder.objects.get(path=new_path.parent)
+            comic.updated_at = Now()
+            comic.presave()
+            new_folder_pks = frozenset(
+                Folder.objects.filter(path__in=new_path.parents).values_list(
+                    "pk", flat=True
+                )
+            )
+            folder_m2m_links[comic.pk] = new_folder_pks
+            updated_comics.append(comic)
+            if del_folder_pks := old_folder_pks - new_folder_pks:
+                for pk in del_folder_pks:
+                    del_folder_rows.append((comic.pk, pk))
+        except Exception:
+            self.log.exception(f"moving {comic.path}")
+
+    def _bulk_comics_move_prepare(self):
+        """Prepare Update Comics."""
+        comics = (
+            Comic.objects.prefetch_related(FOLDERS_FIELD_NAME)
+            .filter(library=self.library, path__in=self.task.files_moved.keys())
+            .only(PATH_FIELD_NAME, PARENT_FOLDER_FIELD_NAME, FOLDERS_FIELD_NAME)
+        )
+
+        folder_m2m_links = {}
+        updated_comics = []
+        del_folder_rows = []
+        for comic in comics:
+            self._prepare_moved_comic(
+                comic, folder_m2m_links, updated_comics, del_folder_rows
+            )
+        self.task.files_moved = {}
+        self.log.debug(f"Prepared {len(updated_comics)} for move...")
+        del_rows_map = {}
+        if del_folder_rows:
+            del_rows_map[FOLDERS_FIELD_NAME] = del_folder_rows
+        return updated_comics, folder_m2m_links, del_rows_map
+
+    def bulk_comics_moved(self):
+        """Move comcis."""
+        num_files_moved = len(self.task.files_moved)
+        status = ImporterMoveComicsStatus(0, num_files_moved)
+        try:
+            if not num_files_moved:
+                return 0
+            self.status_controller.start(status)
+
+            # Prepare
+            self._bulk_comics_moved_ensure_folders()
+            updated_comics, folder_m2m_links, del_rows_map = (
+                self._bulk_comics_move_prepare()
+            )
+
+            # Update comics
+            # Potentially could just add these to the right structures and do it later during create and link.
+            Comic.objects.bulk_update(updated_comics, MOVED_BULK_COMIC_UPDATE_FIELDS)
+            if del_rows_map:
+                self.delete_m2m_field(FOLDERS_FIELD_NAME, del_rows_map, status)
+            if folder_m2m_links:
+                self.link_comic_m2m_field(FOLDERS_FIELD_NAME, folder_m2m_links, status)
+
+            count = len(updated_comics)
+        finally:
+            self.status_controller.finish(status)
+        return count

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

@@ -0,0 +1,88 @@
+"""Bulk import and move covers."""
+
+from pathlib import Path
+
+from django.db.models.functions import Now
+
+from codex.librarian.scribe.importer.const import (
+    CLASS_CUSTOM_COVER_GROUP_MAP,
+    CUSTOM_COVER_UPDATE_FIELDS,
+    LINK_COVER_PKS,
+)
+from codex.librarian.scribe.importer.moved.comics import MovedComicsImporter
+from codex.librarian.scribe.importer.statii.moved import ImporterMoveCoversStatus
+from codex.models import CustomCover
+
+
+class MovedCoversImporter(MovedComicsImporter):
+    """Methods for moving comics and folders."""
+
+    def _bulk_covers_moved_prepare(self, status):
+        """Create an update map for bulk update."""
+        covers = CustomCover.objects.filter(
+            library=self.library, path__in=self.task.covers_moved.keys()
+        ).only("pk", "path")
+
+        if status:
+            status.total = covers.count()
+
+        moved_covers = []
+        unlink_pks = set()
+        for cover in covers.iterator():
+            try:
+                new_path = self.task.covers_moved[cover.path]
+                cover.path = new_path
+                new_path = Path(new_path)
+                cover.updated_at = Now()
+                cover.presave()
+                moved_covers.append(cover)
+                unlink_pks.add(cover.pk)
+            except Exception:
+                self.log.exception(f"moving {cover.path}")
+        return moved_covers, unlink_pks
+
+    def _bulk_covers_moved_unlink(self, unlink_pks):
+        """Unlink moved covers because they could have moved between group dirs."""
+        if not unlink_pks:
+            return
+        self.log.debug(f"Unlinking {len(unlink_pks)} moved custom covers.")
+        for model in CLASS_CUSTOM_COVER_GROUP_MAP:
+            groups = model.objects.filter(custom_cover__in=unlink_pks)
+            unlink_groups = []
+            for group in groups:
+                group.custom_cover = None
+                unlink_groups.append(group)
+            if unlink_groups:
+                model.objects.bulk_update(unlink_groups, ["custom_cover"])
+                self.log.debug(
+                    f"Unlinked {len(unlink_groups)} {model.__name__} moved custom covers."
+                )
+
+        self.remove_covers(unlink_pks, custom=True)
+
+    def bulk_covers_moved(self, status=None):
+        """Move covers."""
+        num_covers_moved = len(self.task.covers_moved)
+        status = ImporterMoveCoversStatus(None, num_covers_moved)
+        try:
+            if not num_covers_moved:
+                return 0
+            self.status_controller.start(status)
+
+            moved_covers, unlink_pks = self._bulk_covers_moved_prepare(status)
+            if LINK_COVER_PKS not in self.metadata:
+                self.metadata[LINK_COVER_PKS] = set()
+            self.metadata[LINK_COVER_PKS].update(unlink_pks)
+            if moved_covers:
+                CustomCover.objects.bulk_update(
+                    moved_covers, CUSTOM_COVER_UPDATE_FIELDS
+                )
+
+            self._bulk_covers_moved_unlink(unlink_pks)
+
+            count = len(moved_covers)
+            level = "INFO" if count else "DEBUG"
+            self.log.log(level, f"Moved {count} custom covers.")
+        finally:
+            self.status_controller.finish(status)
+        return count