codex 1.7.3a2__py3-none-any.whl → 1.7.5__py3-none-any.whl

codex/librarian/bookmark/update.py

@@ -5,6 +5,7 @@ from django.db.models.expressions import F
 from django.db.models.functions import Now
 from django.db.models.query import Q
 
+from codex.choices.notifications import Notifications
 from codex.librarian.mp_queue import LIBRARIAN_QUEUE
 from codex.librarian.notifier.tasks import NotifierTask
 from codex.models import Bookmark, Comic
@@ -28,6 +29,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 +74,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
 
@@ -54,41 +85,45 @@ class BookmarkUpdate(GroupACLMixin):
     def _notify_library_changed(uid):
         """Notify one user that their library changed."""
         group = f"user_{uid}"
-        task = NotifierTask("LIBRARY_CHANGED", group)
+        task = NotifierTask(Notifications.BOOKMARK.value, group)
         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 +134,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

@@ -6,7 +6,7 @@ from pathlib import Path
 
 from codex.librarian.covers.create import CoverCreateThread
 from codex.librarian.covers.status import CoverStatusTypes
-from codex.librarian.notifier.tasks import LIBRARY_CHANGED_TASK
+from codex.librarian.notifier.tasks import COVERS_CHANGED_TASK
 from codex.models import Comic
 from codex.models.paths import CustomCover
 from codex.status import Status
@@ -67,9 +67,9 @@ 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)
+        librarian_queue.put(COVERS_CHANGED_TASK)
 
     def _cleanup_orphan_covers(self, cover_class, cover_root, name):
         """Remove all orphan cover thumbs."""
@@ -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:

codex/librarian/importer/extract.py

@@ -9,8 +9,13 @@ from comicbox.box import Comicbox
 from comicbox.box.computed import IDENTIFIERS_KEY
 from comicbox.exceptions import UnsupportedArchiveTypeError
 from comicbox.schemas.comicbox_mixin import CONTRIBUTORS_KEY
-from django.db.models import CharField
-from django.db.models.fields import DecimalField, PositiveSmallIntegerField
+from django.db.models.fields import (
+    CharField,
+    DecimalField,
+    PositiveSmallIntegerField,
+    TextField,
+)
+from nh3 import clean
 from rarfile import BadRarFile
 
 from codex.librarian.importer.const import FIS, STORY_ARCS_METADATA_KEY
@@ -36,29 +41,39 @@ _MD_INVALID_KEYS = frozenset(
         "updated_at",
     )
 )
-_MD_VALID_KEYS = frozenset(
-    (
-        *(
-            field.name
-            for field in Comic._meta.get_fields()
-            if field.name not in _MD_INVALID_KEYS
-        ),
-        "story_arcs",
+_MD_VALID_KEYS = tuple(
+    sorted(
+        frozenset(
+            (
+                *(
+                    field.name
+                    for field in Comic._meta.get_fields()
+                    if field.name not in _MD_INVALID_KEYS
+                ),
+                "story_arcs",
+            )
+        )
     )
 )
-_MD_CHAR_KEYS = frozenset(
-    field.name for field in Comic._meta.get_fields() if isinstance(field, CharField)
-)
-_MD_DECIMAL_KEYS = frozenset(
-    field.name for field in Comic._meta.get_fields() if isinstance(field, DecimalField)
-)
-_MD_PSI_KEYS = frozenset(
-    {
-        field.name
-        for field in Comic._meta.get_fields()
-        if isinstance(field, PositiveSmallIntegerField)
-    }
-)
+
+
+def _get_keys_by_field_type(field_type):
+    return tuple(
+        sorted(
+            frozenset(
+                field.name
+                for field in Comic._meta.get_fields()
+                if isinstance(field, field_type)
+            )
+        )
+    )
+
+
+_MD_CHAR_KEYS = _get_keys_by_field_type(CharField)
+_MD_TEXT_KEYS = _get_keys_by_field_type(TextField)
+_MD_STR_KEYS = tuple(sorted(_MD_CHAR_KEYS + _MD_TEXT_KEYS))
+_MD_DECIMAL_KEYS = _get_keys_by_field_type(DecimalField)
+_MD_PSI_KEYS = _get_keys_by_field_type(PositiveSmallIntegerField)
 _PSI_MAX = 2**31 - 1
 _SI_MIN = 2**15 * -1
 _SI_MAX = 2**15 - 1
@@ -94,7 +109,7 @@ class ExtractMetadataImporter(QueryForeignKeysImporter):
 
     @classmethod
     def _clean_decimal(cls, value, field_name: str):
-        field: DecimalField = Comic._meta.get_field(field_name)  # type: ignore
+        field: DecimalField = Comic._meta.get_field(field_name)  # type: ignore[reportAssignmentType]
         try:
             quantize_str = Decimal(f"1e-{field.decimal_places}")
             value = value.quantize(quantize_str, rounding=ROUND_DOWN)
@@ -145,11 +160,15 @@ class ExtractMetadataImporter(QueryForeignKeysImporter):
         cls._assign_or_pop(obj, key, value)
 
     @staticmethod
-    def _clean_charfield(model, field_name, value):
+    def _clean_strfield(model, field_name, value):
         try:
-            field: CharField = model._meta.get_field(field_name)  # type: ignore
             if value:
-                value = value[: field.max_length].strip()
+                value = value.strip()
+                field = model._meta.get_field(field_name)  # type: ignore[reportAssignmentType]
+                max_length = getattr(field, "max_length", 0)
+                if max_length:
+                    value = value[:max_length]
+                value = clean(value)
             if not value:
                 value = None
         except Exception:
@@ -157,10 +176,10 @@ class ExtractMetadataImporter(QueryForeignKeysImporter):
         return value
 
     @classmethod
-    def _clean_charfields(cls, md: dict[str, Any]) -> None:
-        for key in _MD_CHAR_KEYS:
+    def _clean_strfields(cls, md: dict[str, Any]) -> None:
+        for key in _MD_STR_KEYS:
             value = md.get(key)
-            value = cls._clean_charfield(Comic, key, value)
+            value = cls._clean_strfield(Comic, key, value)
             cls._assign_or_pop(md, key, value)
 
     @classmethod
@@ -182,10 +201,10 @@ class ExtractMetadataImporter(QueryForeignKeysImporter):
             return
         clean_contributors = {}
         for role, persons in contributors.items():
-            clean_role = cls._clean_charfield(ContributorRole, "name", role)
+            clean_role = cls._clean_strfield(ContributorRole, "name", role)
             clean_persons = set()
             for person in persons:
-                clean_person = cls._clean_charfield(ContributorPerson, "name", person)
+                clean_person = cls._clean_strfield(ContributorPerson, "name", person)
                 if clean_person:
                     clean_persons.add(clean_person)
             clean_contributors[clean_role] = clean_persons
@@ -198,7 +217,7 @@ class ExtractMetadataImporter(QueryForeignKeysImporter):
             return
         clean_story_arcs = {}
         for story_arc, number in story_arcs.items():
-            clean_story_arc = cls._clean_charfield(StoryArc, "name", story_arc)
+            clean_story_arc = cls._clean_strfield(StoryArc, "name", story_arc)
             if clean_story_arc:
                 clean_story_arcs[clean_story_arc] = number
         cls._assign_or_pop(md, STORY_ARCS_METADATA_KEY, clean_story_arcs)
@@ -210,11 +229,11 @@ class ExtractMetadataImporter(QueryForeignKeysImporter):
             return
         clean_identifiers = {}
         for nid, identifier in identifiers.items():
-            clean_id_type = cls._clean_charfield(IdentifierType, "name", nid)
+            clean_id_type = cls._clean_strfield(IdentifierType, "name", nid)
             nss = identifier.get("nss")
-            clean_nss = cls._clean_charfield(Identifier, "nss", nss)
+            clean_nss = cls._clean_strfield(Identifier, "nss", nss)
             url = identifier.get("url")
-            clean_url = cls._clean_charfield(Identifier, "url", url)
+            clean_url = cls._clean_strfield(Identifier, "url", url)
             if clean_nss:
                 clean_identifier = {"nss": nss}
                 if clean_url:
@@ -230,7 +249,7 @@ class ExtractMetadataImporter(QueryForeignKeysImporter):
         cls._clean_comic_positive_small_ints(md)
         cls._clean_comic_small_ints(md)
         cls._clean_comic_decimals(md)
-        cls._clean_charfields(md)
+        cls._clean_strfields(md)
         cls._clean_contributors(md)
         cls._clean_story_arcs(md)
         cls._clean_identifiers(md)

codex/librarian/importer/failed_imports.py

@@ -120,7 +120,7 @@ class FailedImportsImporter(DeletedImporter):
             create_objs,
             update_conflicts=True,
             update_fields=_BULK_UPDATE_FAILED_IMPORT_FIELDS,
-            unique_fields=FailedImport._meta.unique_together[0],  # type: ignore
+            unique_fields=FailedImport._meta.unique_together[0],
         )
         count = len(create_objs)
         if count:

codex/librarian/importer/importer.py

@@ -7,7 +7,10 @@ from humanize import naturaldelta
 
 from codex.librarian.importer.moved import MovedImporter
 from codex.librarian.importer.status import ImportStatusTypes
-from codex.librarian.notifier.tasks import FAILED_IMPORTS_TASK, LIBRARY_CHANGED_TASK
+from codex.librarian.notifier.tasks import (
+    FAILED_IMPORTS_CHANGED_TASK,
+    LIBRARY_CHANGED_TASK,
+)
 from codex.librarian.search.tasks import SearchIndexUpdateTask
 from codex.librarian.tasks import DelayedTasks
 
@@ -43,12 +46,14 @@ class ComicImporter(MovedImporter):
 
             # Wait to start the search index update in case more updates are incoming.
             until = time() + 1
-            delayed_search_task = DelayedTasks(until, (SearchIndexUpdateTask(False),))
+            delayed_search_task = DelayedTasks(
+                until, (SearchIndexUpdateTask(rebuild=False),)
+            )
             self.librarian_queue.put(delayed_search_task)
         else:
             self.log.info("No updates neccissary.")
         if new_failed_imports:
-            self.librarian_queue.put(FAILED_IMPORTS_TASK)
+            self.librarian_queue.put(FAILED_IMPORTS_CHANGED_TASK)
 
     def apply(self):
         """Bulk import comics."""

codex/librarian/importer/importerd.py

@@ -35,7 +35,7 @@ class ComicImporterThread(QueuedThread):
         import_comics = Comic.objects.filter(pk__in=task.pks).only("path", "library_id")
         library_path_map = {}
         for import_comic in import_comics:
-            library_id = import_comic.library_id  # type: ignore
+            library_id = import_comic.library_id  # type: ignore[reportAttributeAccessIssue]
             if library_id not in library_path_map:
                 library_path_map[library_id] = set()
             library_path_map[library_id].add(import_comic.path)
@@ -89,7 +89,7 @@ class ComicImporterThread(QueuedThread):
         importer.bulk_folders_moved()
         return True
 
-    def _adopt_orphan_folders(self, janitor=False):
+    def _adopt_orphan_folders(self, janitor: bool):
         """Find orphan folders and move them into their correct place."""
         status = Status(ImportStatusTypes.ADOPT_FOLDERS)
         moved_status = Status(ImportStatusTypes.DIRS_MOVED)
@@ -118,6 +118,6 @@ class ComicImporterThread(QueuedThread):
         elif isinstance(task, UpdateGroupsTask):
             self._update_groups(task)
         elif isinstance(task, AdoptOrphanFoldersTask):
-            self._adopt_orphan_folders(task.janitor)
+            self._adopt_orphan_folders(janitor=task.janitor)
         else:
             self.log.warning(f"Bad task sent to library updater {task}")