codex 1.6.0a6__py3-none-any.whl → 1.6.0a8__py3-none-any.whl

codex/exceptions.py

@@ -30,6 +30,7 @@ class SeeOtherRedirectError(APIException):
         route: dict = detail.get("route", {})  # type: ignore
         params: dict = route.get("params", DEFAULTS["breadcrumbs"][0])
         # Save route in server format for redirect reverse
+        params.pop("name", None)
         self.route_kwargs = params
         # Serialize route for detail
         serializer = RouteSerializer(params)

codex/integrity.py

@@ -36,7 +36,7 @@ MIGRATION_0011 = "0010_library_groups_and_metadata_changes"
 MIGRATION_0018 = "0018_rename_userbookmark_bookmark"
 MIGRATION_0025 = "0025_add_story_arc_number"
 MIGRATION_0026 = "0026_comicbox_1"
-MIGRATION_0028 = "0028_custom_covers"  # TODO merge with 27
+MIGRATION_0027 = "0027_import_order_and_covers"
 M2M_NAMES = MappingProxyType(
     {
         "Character": "characters",
@@ -308,7 +308,7 @@ def _repair_library_groups(apps):
 
 
 def _delete_extra_custom_cover_libraries(apps):
-    if not has_applied_migration(MIGRATION_0028):
+    if not has_applied_migration(MIGRATION_0027):
         return
     library_model = apps.get_model("codex", "library")
     custom_cover_libraries = library_model.objects.filter(covers_only=True)
@@ -339,7 +339,7 @@ def _delete_extra_custom_cover_libraries(apps):
 
 
 def _repair_groups_with_custom_covers(apps):
-    if not has_applied_migration(MIGRATION_0028):
+    if not has_applied_migration(MIGRATION_0027):
         return
     custom_cover_model = apps.get_model("codex", "customcover")
     now = Now()
@@ -366,7 +366,7 @@ def _delete_errors():
 
     for host_model_name in HAVE_LIBRARY_FKS:
         if host_model_name == "CustomCover" and not has_applied_migration(
-            MIGRATION_0028
+            MIGRATION_0027
         ):
             continue
         _delete_fk_integrity_errors(apps, host_model_name, "Library", "library")

codex/librarian/importer/{aggregate_metadata.py → aggregate.py}

@@ -2,13 +2,7 @@
 
 from collections.abc import Mapping
 from pathlib import Path
-from zipfile import BadZipFile
 
-from comicbox.box import Comicbox
-from comicbox.exceptions import UnsupportedArchiveTypeError
-from rarfile import BadRarFile
-
-from codex.librarian.importer.clean_metadata import CleanMetadataMixin
 from codex.librarian.importer.const import (
     COMIC_FK_FIELD_NAMES,
     COMIC_M2M_FIELD_NAMES,
@@ -24,13 +18,15 @@ from codex.librarian.importer.const import (
     MDS,
     VOLUME_COUNT,
 )
-from codex.librarian.importer.status import ImportStatusTypes, status_notify
+from codex.librarian.importer.extract import ExtractMetadataImporter
+from codex.librarian.importer.status import ImportStatusTypes
 from codex.models import Imprint, Publisher, Series, Volume
 from codex.models.admin import AdminFlag
 from codex.status import Status
+from codex.util import max_none
 
 
-class AggregateMetadataMixin(CleanMetadataMixin):
+class AggregateMetadataImporter(ExtractMetadataImporter):
     """Aggregate metadata from comics to prepare for importing."""
 
     _BROWSER_GROUPS = (Publisher, Imprint, Series, Volume)
@@ -86,37 +82,13 @@ class AggregateMetadataMixin(CleanMetadataMixin):
         m2m_md[FOLDERS_FIELD] = Path(path).parents
         return m2m_md
 
-    def _get_path_metadata(self, path, import_metadata):
+    def _get_path_metadata(self, md, path):
         """Get the metadata from comicbox and munge it a little."""
-        md = {}
-        fk_md = {}
-        group_tree_md = {}
-        m2m_md = {}
-        failed_import = {}
-        try:
-            if import_metadata:
-                with Comicbox(path) as cb:
-                    md = cb.to_dict()
-                    md = md.get("comicbox", {})
-                    if "file_type" not in md:
-                        md["file_type"] = cb.get_file_type()
-                    if "page_count" not in md:
-                        md["page_count"] = cb.get_page_count()
-
-            md["path"] = path
-            md = self.clean_md(md)
-
-            group_tree_md = self._get_group_tree(md)
-            fk_md = self._get_fk_metadata(md)
-            m2m_md = self._get_m2m_metadata(md, path)
-
-        except (UnsupportedArchiveTypeError, BadRarFile, BadZipFile, OSError) as exc:
-            self.log.warning(f"Failed to import {path}: {exc}")
-            failed_import = {path: exc}
-        except Exception as exc:
-            self.log.exception(f"Failed to import: {path}")
-            failed_import = {path: exc}
-        return md, m2m_md, fk_md, group_tree_md, failed_import
+        group_tree_md = self._get_group_tree(md)
+        fk_md = self._get_fk_metadata(md)
+        m2m_md = self._get_m2m_metadata(md, path)
+
+        return md, m2m_md, fk_md, group_tree_md
 
     @staticmethod
     def _aggregate_m2m_metadata_dict_value(names, key, values, all_fks):
@@ -182,22 +154,13 @@ class AggregateMetadataMixin(CleanMetadataMixin):
                 all_fks[field] = set()
             all_fks[field].add(name)
 
-    @staticmethod
-    def _none_max(a, b):
-        """None aware math.max."""
-        if a is not None and b is not None:
-            return max(a, b)
-        if a is None:
-            return b
-        return a
-
     @classmethod
     def _set_max_group_count(cls, common_args, group_class, index, count_key):
         """Assign the maximum group count number."""
         all_fks, group_tree, group_md = common_args
         group_name = group_tree[0:index]
         try:
-            count = cls._none_max(
+            count = max_none(
                 all_fks[GROUP_TREES][Series].get(group_name),
                 group_md.get(count_key),
             )
@@ -215,72 +178,79 @@ class AggregateMetadataMixin(CleanMetadataMixin):
             cls._set_max_group_count(common_args, Series, 3, VOLUME_COUNT)
             cls._set_max_group_count(common_args, Volume, 4, ISSUE_COUNT)
 
-    def _aggregate_path(self, data, path, import_metadata):
+    def _aggregate_path(self, md, path, status):
         """Aggregate metadata for one path."""
-        path_str = str(path)
-        md, m2m_md, fk_md, group_tree_md, failed_import = self._get_path_metadata(
-            path_str, import_metadata
-        )
+        md, m2m_md, fk_md, group_tree_md = self._get_path_metadata(md, path)
 
-        all_failed_imports, all_mds, all_m2m_mds, all_fks, status = data
-        if failed_import:
-            all_failed_imports.update(failed_import)
-        else:
-            if md:
-                all_mds[path_str] = md
+        path_str = str(path)
+        if md:
+            all_mds = self.metadata[MDS]
+            all_mds[path_str] = md
 
-            if m2m_md:
-                self._aggregate_m2m_metadata(all_m2m_mds, m2m_md, all_fks, path_str)
+        all_fks = self.metadata[FKS]
+        if m2m_md:
+            all_m2m_mds = self.metadata[M2M_MDS]
+            self._aggregate_m2m_metadata(all_m2m_mds, m2m_md, all_fks, path_str)
 
-            if fk_md:
-                self._aggregate_fk_metadata(all_fks, fk_md)
+        if fk_md:
+            self._aggregate_fk_metadata(all_fks, fk_md)
 
-            if group_tree_md:
-                self._aggregate_group_tree_metadata(all_fks, group_tree_md)
+        if group_tree_md:
+            self._aggregate_group_tree_metadata(all_fks, group_tree_md)
 
         if status:
             status.complete += 1
             self.status_controller.update(status)
 
-    @status_notify(status_type=ImportStatusTypes.AGGREGATE_TAGS)
-    def get_aggregate_metadata(  # noqa: PLR0913
+    def get_aggregate_metadata(
         self,
-        all_paths,
-        library_path,
-        metadata,
-        force_import_metadata,
         status=None,
     ):
         """Get aggregated metadata for the paths given."""
+        all_paths = self.task.files_modified | self.task.files_created
         total_paths = len(all_paths)
+
         if not total_paths:
             return 0
-        self.log.info(f"Reading tags from {total_paths} comics in {library_path}...")
-        all_mds = metadata[MDS]
-        all_m2m_mds = metadata[M2M_MDS]
-        all_fks = metadata[FKS]
-        all_fks[GROUP_TREES] = {cls: {} for cls in self._BROWSER_GROUPS}
-        all_failed_imports = metadata[FIS]
-
-        if status and status.complete is None:
-            status.complete = 0
-        key = AdminFlag.FlagChoices.IMPORT_METADATA.value  # type: ignore
-        if force_import_metadata:
+        self.log.info(
+            f"Reading tags from {total_paths} comics in {self.library.path}..."
+        )
+        status = Status(ImportStatusTypes.AGGREGATE_TAGS, 0, total_paths)
+        self.status_controller.start(status, notify=False)
+
+        # Set import_metadata flag
+        if self.task.force_import_metadata:
             import_metadata = True
         else:
+            key = AdminFlag.FlagChoices.IMPORT_METADATA.value  # type: ignore
             import_metadata = AdminFlag.objects.get(key=key).on
         if not import_metadata:
             self.log.warn("Admin flag set to NOT import metadata.")
-        data = (all_failed_imports, all_mds, all_m2m_mds, all_fks, status)
+
+        # Init metadata, extract and aggregate
+        self.metadata[MDS] = {}
+        self.metadata[M2M_MDS] = {}
+        self.metadata[FKS] = {GROUP_TREES: {cls: {} for cls in self._BROWSER_GROUPS}}
+        self.metadata[FIS] = {}
         for path in all_paths:
-            self._aggregate_path(data, path, import_metadata)
+            md = self.extract_and_clean(path, import_metadata)
+            if md:
+                self._aggregate_path(md, path, status)
 
-        all_fks[COMIC_PATHS] = frozenset(all_mds.keys())
-        fi_status = Status(ImportStatusTypes.FAILED_IMPORTS, 0, len(all_failed_imports))
+        # Aggregate further
+        self.metadata[FKS][COMIC_PATHS] = frozenset(self.metadata[MDS].keys())
+        fis = self.metadata[FIS]
+        self.task.files_modified -= fis.keys()
+        self.task.files_created -= fis.keys()
+
+        # Set statii
+        fi_status = Status(ImportStatusTypes.FAILED_IMPORTS, 0, len(fis))
         self.status_controller.update(
             fi_status,
             notify=False,
         )
         count = status.complete if status else 0
         self.log.info(f"Aggregated tags from {count} comics.")
+
+        self.status_controller.finish(status)
         return count

codex/librarian/importer/cache.py

@@ -0,0 +1,180 @@
+"""Update Groups timestamp for cover cache busting."""
+
+import os
+
+from django.db.models.aggregates import Count
+from django.db.models.functions.datetime import Now
+from django.db.models.query import Q
+
+from codex.librarian.importer.init import InitImporter
+from codex.librarian.importer.status import ImportStatusTypes
+from codex.models import Comic, Folder, Imprint, Publisher, Series, StoryArc, Volume
+from codex.status import Status
+
+_FIRST_COVER_MODEL_UPDATE_ORDER = (Volume, Series, Imprint, Publisher, Folder, StoryArc)
+_UPDATE_FIELDS = ("first_comic", "updated_at")
+
+
+class CacheUpdateImporter(InitImporter):
+    """Update Groups timestamp for cover cache busting."""
+
+    @staticmethod
+    def _get_folder_batches(model_qs):
+        """Create batches of folders by folder depth level."""
+        # Collect all related folders
+        folder_pks = model_qs.values_list("pk", flat=True)
+        all_folders = (
+            Folder.objects.filter(Q(folder__pk__in=folder_pks) | Q(pk__in=folder_pks))
+            .select_related("first_comic")
+            .only("path", *_UPDATE_FIELDS)
+        )
+
+        # Create a map of each folder by path depth level
+        batch_map = {}
+        for folder in all_folders:
+            depth = folder.path.count(os.sep)
+            if depth not in batch_map:
+                batch_map[depth] = set()
+            batch_map[depth].add(folder)
+
+        # Order batches by reverse depth level to update bottom up.
+        batches = []
+        for _, folders in sorted(batch_map.items(), reverse=True):
+            batches.append(folders)
+
+        return tuple(batches)
+
+    @staticmethod
+    def _update_first_cover_volume(obj):
+        qs = Comic.objects.filter(volume=obj)
+        qs = qs.order_by("issue_number", "issue_suffix", "sort_name").only("pk")
+        obj.first_comic = qs.first()
+
+    @staticmethod
+    def _update_first_cover_group(obj, model, field):
+        qs = model.objects.filter(**{field: obj})
+        order_by = "name" if model == Volume else "sort_name"
+        qs = qs.select_related("first_comic").order_by(order_by).only("first_comic")
+        obj.first_comic = qs.first().first_comic
+
+    @staticmethod
+    def _update_first_cover_story_arc(obj):
+        qs = Comic.objects.filter(story_arc_numbers__story_arc=obj)
+        qs = qs.order_by("story_arc_numbers__number", "date").only("pk")
+        obj.first_comic = qs.first()
+
+    @staticmethod
+    def _update_first_cover_folder(obj):
+        first_comic = (
+            Comic.objects.filter(parent_folder=obj)
+            .order_by("path")
+            .only("path")
+            .first()
+        )
+        first_folder = (
+            Folder.objects.filter(parent_folder=obj)
+            .select_related("first_comic")
+            .order_by("path")
+            .only("first_comic", "path")
+            .first()
+        )
+        if first_comic and not first_folder:
+            obj.first_comic = first_comic
+        elif first_folder and not first_comic:
+            obj.first_comic = first_folder.first_comic
+        elif first_folder and first_comic:
+            if first_comic and first_comic.path < first_folder.path:
+                obj.first_comic = first_comic
+            else:
+                obj.first_comic = first_folder.first_comic
+
+    @classmethod
+    def _update_first_cover(cls, model, obj):
+        if model == Volume:
+            cls._update_first_cover_volume(obj)
+        elif model == Series:
+            cls._update_first_cover_group(obj, Volume, "series")
+        elif model == Imprint:
+            cls._update_first_cover_group(obj, Series, "imprint")
+        elif model == Publisher:
+            cls._update_first_cover_group(obj, Imprint, "publisher")
+        elif model == StoryArc:
+            cls._update_first_cover_story_arc(obj)
+        elif model == Folder:
+            cls._update_first_cover_folder(obj)
+
+    @classmethod
+    def _update_group_first_comic(
+        cls, force_update_group_map, model, start_time, log_list
+    ):
+        rel = "storyarcnumber__" if model == StoryArc else ""
+        updated_at_rel = rel + "comic__updated_at__gt"
+        updated_filter = {updated_at_rel: start_time}
+        filter_query = (
+            Q(**updated_filter)
+            | Q(first_comic__isnull=True)
+            | Q(updated_at__gt=start_time)
+        )
+        if model != Volume:
+            filter_query |= Q(custom_cover__updated_at__gt=start_time)
+        pks = force_update_group_map.get(model)
+        if pks:
+            filter_query |= Q(pk__in=pks)
+        model_qs = model.objects.filter(filter_query)
+
+        # only update those with comics
+        rel_prefix = "storyarcnumber__" if model == StoryArc else ""
+        rel_prefix += "comic"
+        model_qs = model_qs.alias(child_count=Count(f"{rel_prefix}__pk", distinct=True))
+        model_qs = model_qs.filter(child_count__gt=0)
+        model_qs = model_qs.distinct()
+        if model == Folder:
+            batches = cls._get_folder_batches(model_qs)
+        else:
+            model_qs.select_related("first_comic").only(*_UPDATE_FIELDS)
+            batches = (model_qs,)
+
+        total_count = 0
+        for model_qs in batches:
+            updated = []
+            for obj in model_qs:
+                cls._update_first_cover(model, obj)
+                obj.updated_at = Now()
+                updated.append(obj)
+
+            count = len(updated)
+            if count:
+                model.objects.bulk_update(updated, _UPDATE_FIELDS)
+                total_count += count
+        if total_count:
+            log_list.append(f"{total_count} {model.__name__}s")
+        return total_count
+
+    def update_all_groups_first_comics(self, force_update_group_map, start_time):
+        """Update timestamps for each group for cover cache busting."""
+        total_count = 0
+        status = Status(ImportStatusTypes.GROUP_UPDATE)
+        self.status_controller.start(status)
+        try:
+            log_list = []
+            for model in _FIRST_COVER_MODEL_UPDATE_ORDER:
+                # self.log.debug(f"Updating first covers for {model.__name__}s...")
+                count = self._update_group_first_comic(
+                    force_update_group_map, model, start_time, log_list
+                )
+                if count:
+                    self.log.debug(
+                        f"Updated {count} first covers for {model.__name__}s"
+                    )
+                status.add_complete(count)
+                self.status_controller.update(status, notify=False)
+                total_count += count
+
+            if total_count:
+                groups_log = ", ".join(log_list)
+                self.log.info(  # type: ignore
+                    f"Updated first covers for {groups_log}."
+                )
+                self.changed += total_count
+        finally:
+            self.status_controller.finish(status)

codex/librarian/importer/const.py

@@ -115,12 +115,7 @@ DICT_MODEL_REL_LINK_MAP = MappingProxyType(
 # BULK UPDATE #
 ###############
 
-_EXCLUDEBULK_UPDATE_COMIC_FIELDS = {
-    "created_at",
-    "searchresult",
-    "id",
-    "bookmark",
-}
+_EXCLUDEBULK_UPDATE_COMIC_FIELDS = {"bookmark", "created_at", "id", "library"}
 GROUP_BASE_FIELDS = ("name", "sort_name")
 BULK_UPDATE_COMIC_FIELDS = tuple(
     sorted(
@@ -130,6 +125,7 @@ BULK_UPDATE_COMIC_FIELDS = tuple(
         and (field.name not in _EXCLUDEBULK_UPDATE_COMIC_FIELDS)
     )
 )
+BULK_CREATE_COMIC_FIELDS = (*BULK_UPDATE_COMIC_FIELDS, "library")
 BULK_UPDATE_FOLDER_FIELDS = (
     *GROUP_BASE_FIELDS,
     "stat",
@@ -189,6 +185,10 @@ MDS = "mds"
 M2M_MDS = "m2m_mds"
 FKS = "fks"
 FIS = "fis"
+FK_CREATE = "fk_create"
+COVERS_UPDATE = "covers_update"
+COVERS_CREATE = "covers_create"
+LINK_COVER_PKS = "link_cover_pks"
 GROUP_COMPARE_FIELDS = MappingProxyType(
     {
         Series: ("publisher__name", "imprint__name", "name"),
@@ -227,3 +227,12 @@ COMIC_GROUP_FIELD_NAMES = (
     "story_arc_numbers",
     "folders",
 )
+
+FKC_CONTRIBUTORS = "create_contributors"
+FKC_STORY_ARC_NUMBERS = "create_story_arc_numbers"
+FKC_IDENTIFIERS = "create_identifiers"
+FKC_CREATE_GROUPS = "create_groups"
+FKC_UPDATE_GROUPS = "update_groups"
+FKC_CREATE_FKS = "create_fks"
+FKC_FOLDER_PATHS = "create_folder_paths"
+FKC_TOTAL_FKS = "total_fks"

codex/librarian/importer/create_comics.py

@@ -1,39 +1,122 @@
 """Bulk update and create comic objects and bulk update m2m fields."""
 
-from codex.librarian.importer.const import BULK_UPDATE_COMIC_FIELDS
-from codex.librarian.importer.link_comics import LinkComicsMixin
-from codex.librarian.importer.status import ImportStatusTypes, status_notify
+from django.db.models import NOT_PROVIDED
+from django.db.models.functions import Now
+
+from codex.librarian.importer.const import (
+    BULK_CREATE_COMIC_FIELDS,
+    BULK_UPDATE_COMIC_FIELDS,
+    BULK_UPDATE_COMIC_FIELDS_WITH_VALUES,
+    MDS,
+)
+from codex.librarian.importer.link_comics import LinkComicsImporter
+from codex.librarian.importer.status import ImportStatusTypes
 from codex.models import (
     Comic,
 )
+from codex.status import Status
 
 
-class CreateComicsMixin(LinkComicsMixin):
+class CreateComicsImporter(LinkComicsImporter):
     """Create comics methods."""
 
-    @status_notify(status_type=ImportStatusTypes.FILES_CREATED, updates=False)
-    def bulk_create_comics(self, comic_paths, library, mds, **kwargs):
-        """Bulk create comics."""
-        if not comic_paths:
-            return 0
-        num_comics = len(comic_paths)
+    def _bulk_update_comics_add_comic(self, now, comic, results):
+        """Add one comic and stats to the bulk update list."""
+        try:
+            md = self.metadata[MDS].pop(comic.path)
+            self.get_comic_fk_links(md, comic.path)
+            for field_name in BULK_UPDATE_COMIC_FIELDS_WITH_VALUES:
+                value = md.get(field_name)
+                if value is None:
+                    default_value = Comic._meta.get_field(field_name).default
+                    if default_value != NOT_PROVIDED:
+                        value = default_value
+                setattr(comic, field_name, value)
+            comic.presave()
+            comic.updated_at = now
+            update_comics, comic_pks, comic_update_paths = results
+            update_comics.append(comic)
+            comic_pks.append(comic.pk)
+            comic_update_paths.add(comic.path)
+        except Exception:
+            self.log.exception(f"Error preparing {comic} for update.")
 
+    def bulk_update_comics(self):
+        """Bulk update comics, and move nonextant comics into create job.."""
+        num_comics = len(self.task.files_modified)
+        if not num_comics:
+            return num_comics
+
+        self.log.debug(
+            f"Preparing {num_comics} comics for update in library {self.library.path}."
+        )
+        status = Status(ImportStatusTypes.FILES_MODIFIED, 0, num_comics)
+        self.status_controller.start(status, notify=False)
+        # Get existing comics to update
+        comics = Comic.objects.filter(
+            library=self.library, path__in=self.task.files_modified
+        ).only(*BULK_UPDATE_COMIC_FIELDS)
+
+        # set attributes for each comic
+        update_comics = []
+        now = Now()
+        comic_pks = []
+        comic_update_paths = set()
+        results = update_comics, comic_pks, comic_update_paths
+        for comic in comics.iterator():
+            self._bulk_update_comics_add_comic(now, comic, results)
+
+        converted_create_paths = frozenset(
+            set(self.task.files_modified) - comic_update_paths
+        )
+        self.task.files_created |= converted_create_paths
+        count = len(converted_create_paths)
+        if count:
+            self.log.info(f"Converted {count} update paths to create paths.")
+
+        self.log.debug(f"Bulk updating {len(update_comics)} comics.")
+        try:
+            Comic.objects.bulk_update(update_comics, BULK_UPDATE_COMIC_FIELDS)
+            count = len(update_comics)
+
+            self._remove_covers(comic_pks, False)  # type: ignore
+            self.log.debug(f"Purging covers for {len(comic_pks)} updated comics.")
+            if count:
+                self.log.info(f"Updated {count} comics.")
+        except Exception:
+            self.log.exception(f"While updating {comic_update_paths}")
+
+        self.task.files_modified = frozenset()
+
+        self.status_controller.finish(status)
+        return count
+
+    def bulk_create_comics(self):
+        """Bulk create comics."""
+        num_comics = len(self.task.files_created)
+        if not num_comics:
+            return num_comics
         # prepare create comics
         self.log.debug(
-            f"Preparing {num_comics} comics for creation in library {library.path}."
+            f"Preparing {num_comics} comics for creation in library {self.library.path}."
         )
+        status = Status(ImportStatusTypes.FILES_CREATED, 0, num_comics)
+        self.status_controller.start(status, notify=False)
+
         create_comics = []
-        for path in comic_paths:
+        for path in sorted(self.task.files_created):
             try:
-                md = mds.pop(path, {})
-                self.get_comic_fk_links(md, library, path)
-                comic = Comic(**md)
+                md = self.metadata[MDS].pop(path, {})
+                self.get_comic_fk_links(md, path)
+                comic = Comic(**md, library=self.library)
                 comic.presave()
                 create_comics.append(comic)
             except KeyError:
                 self.log.warning(f"No comic metadata for {path}")
             except Exception:
                 self.log.exception(f"Error preparing {path} for create.")
+        self.task.files_created = frozenset()
+        self.metadata.pop(MDS)
 
         num_comics = len(create_comics)
         count = 0
@@ -43,13 +126,15 @@ class CreateComicsMixin(LinkComicsMixin):
                 Comic.objects.bulk_create(
                     create_comics,
                     update_conflicts=True,
-                    update_fields=BULK_UPDATE_COMIC_FIELDS,
+                    update_fields=BULK_CREATE_COMIC_FIELDS,
                     unique_fields=Comic._meta.unique_together[0],  # type: ignore
                 )
                 count = len(create_comics)
                 if count:
                     self.log.info(f"Created {count} comics.")
             except Exception:
-                self.log.exception(f"While creating {comic_paths}")
+                self.log.exception(f"While creating {num_comics} comics")
 
+        self.changed += count
+        self.status_controller.finish(status)
         return count