codex 1.7.2__py3-none-any.whl → 1.7.3__py3-none-any.whl

codex/asgi.py

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

codex/choices.py

@@ -12,17 +12,18 @@ BROWSER_BOOKMARK_FILTER_CHOICES = MappingProxyType(
 )
 BROWSER_ORDER_BY_CHOICES = MappingProxyType(
     {
+        "created_at": "Added Time",
         "age_rating": "Age Rating",
-        "bookmark_updated_at": "Last Read",
+        "child_count": "Child Count",
         "community_rating": "Community Rating",
-        "created_at": "Added Time",
         "critical_rating": "Critical Rating",
-        "date": "Publish Date",
         "filename": "Filename",
-        "page_count": "Page Count",
-        "search_score": "Search Score",
         "size": "File Size",
+        "bookmark_updated_at": "Last Read",
         "sort_name": "Name",
+        "page_count": "Page Count",
+        "date": "Publish Date",
+        "search_score": "Search Score",
         "story_arc_number": "Story Arc Number",
         "updated_at": "Updated Time",
     }
@@ -92,7 +93,6 @@ BROWSER_DEFAULTS = MappingProxyType(
         "order_by": "sort_name",
         "order_reverse": False,
         "q": "",
-        # "search_results_limit": 100,
         "show": _DEFAULT_SHOW,
         "top_group": "p",
         "twenty_four_hour_time": False,
@@ -116,6 +116,7 @@ ADMIN_FLAG_CHOICES = MappingProxyType(
         "NU": "Non Users",
         "RG": "Registration",
         "ST": "Send Stats",
+        "BT": "Banner Text",
     }
 )
 
@@ -389,11 +390,9 @@ ADMIN_TASK_GROUPS = MappingProxyType(
 
 def _group_task_values(groups):
     """Extract values into sorted tuple."""
-    values = []
-    for group in groups["tasks"]:
-        for item in group["tasks"]:
-            values.append(item["value"])
-    return tuple(sorted(values))
+    return tuple(
+        sorted([item["value"] for group in groups["tasks"] for item in group["tasks"]])
+    )
 
 
 ADMIN_TASKS = _group_task_values(ADMIN_TASK_GROUPS)

codex/choices_to_json.py

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

codex/db.py

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

codex/exceptions.py

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

codex/librarian/bookmark/bookmarkd.py

@@ -14,23 +14,26 @@ class BookmarkThread(AggregateMessageQueuedThread, BookmarkUpdate):
     def aggregate_items(self, item):
         """Aggregate bookmark updates."""
         if isinstance(item, BookmarkUpdateTask):
-            key = (tuple(item.auth_filter.items()), tuple(item.comic_filter.items()))
+            key = (tuple(item.auth_filter.items()), item.comic_pks)
             if key not in self.cache:
                 self.cache[key] = {}
             self.cache[key].update(item.updates)
         else:
             self.log.warning(f"Unknown Bookmark task {item}")
 
+    def _send_item(self, filters, updates):
+        """Process one item."""
+        auth_filter, comic_pks = filters
+        auth_filter = dict(auth_filter)
+        self.update_bookmarks(auth_filter, comic_pks, updates, self.log)
+        self.log.debug(f"updated {auth_filter} pk__in={comic_pks}")
+
     def send_all_items(self):
         """Run the task method."""
         cleanup = set()
         for filters, updates in self.cache.items():
             try:
-                auth_filter, comic_filter = filters
-                auth_filter = dict(auth_filter)
-                comic_filter = dict(comic_filter)
-                self.update_bookmarks(auth_filter, comic_filter, updates, self.log)
-                self.log.debug(f"updated {auth_filter | comic_filter}")
+                self._send_item(filters, updates)
                 cleanup.add(filters)
             except Exception:
                 self.log.exception("Updating bookmarks")

codex/librarian/bookmark/tasks.py

@@ -15,5 +15,5 @@ class BookmarkUpdateTask(BookmarkTask):
     """Bookmark a page."""
 
     auth_filter: Mapping[str, int | str]
-    comic_filter: Mapping[str, Any]
+    comic_pks: tuple[int]
     updates: Mapping[str, Any]

codex/librarian/bookmark/update.py

@@ -10,9 +10,8 @@ from codex.librarian.notifier.tasks import NotifierTask
 from codex.models import Bookmark, Comic
 from codex.models.admin import UserActive
 from codex.views.auth import GroupACLMixin
-from codex.views.mixins import BookmarkSearchMixin
 
-VERTICAL_READING_DIRECTIONS = frozenset({"ttb", "btt"})
+_VERTICAL_READING_DIRECTIONS = frozenset({"ttb", "btt"})
 _BOOKMARK_UPDATE_FIELDS = frozenset(
     {
         "page",
@@ -22,10 +21,9 @@ _BOOKMARK_UPDATE_FIELDS = frozenset(
         "reading_direction",
     }
 )
-_COMIC_ONLY_FIELDS = ("pk", "page_count")
 
 
-class BookmarkUpdate(GroupACLMixin, BookmarkSearchMixin):
+class BookmarkUpdate(GroupACLMixin):
     """Update Bookmarks."""
 
     # Used by Bookmarkd and view.bookmark.
@@ -47,10 +45,8 @@ class BookmarkUpdate(GroupACLMixin, BookmarkSearchMixin):
     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 rd in VERTICAL_READING_DIRECTIONS
-            or bm.reading_direction in VERTICAL_READING_DIRECTIONS
+        if bm.two_pages and bool(
+            {rd, bm.reading_direction}.intersection(_VERTICAL_READING_DIRECTIONS)
         ):
             updates["two_pages"] = None
 
@@ -62,13 +58,13 @@ class BookmarkUpdate(GroupACLMixin, BookmarkSearchMixin):
         LIBRARIAN_QUEUE.put(task)
 
     @classmethod
-    def _update_bookmarks(cls, search_kwargs, updates, user) -> int:
+    def _update_bookmarks(cls, auth_filter, comic_pks, updates, user) -> 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(**search_kwargs)
+        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(
@@ -98,12 +94,12 @@ class BookmarkUpdate(GroupACLMixin, BookmarkSearchMixin):
         """Force vertical view to not use two pages."""
         if (
             updates.get("two_pages")
-            and updates.get("reading_direction") in VERTICAL_READING_DIRECTIONS
+            and updates.get("reading_direction") in _VERTICAL_READING_DIRECTIONS
         ):
             updates.pop("two_pages", None)
 
     @classmethod
-    def _create_bookmarks(cls, comic_filter, search_kwargs, updates, user) -> int:
+    def _create_bookmarks(cls, auth_filter, comic_pks, updates, user) -> int:
         """Create new bookmarks for comics that don't exist yet."""
         count = 0
         cls._create_bookmarks_validate_two_pages(updates)
@@ -112,27 +108,19 @@ class BookmarkUpdate(GroupACLMixin, BookmarkSearchMixin):
         create_bookmarks = []
         group_acl_filter = cls.get_group_acl_filter(Comic, user)
         exclude = {}
-        for key, value in search_kwargs.items():
+        for key, value in auth_filter.items():
             exclude["bookmark__" + key] = value
-        query_filter = group_acl_filter & Q(**comic_filter) & ~Q(**exclude)
-        create_bookmark_comics = Comic.objects.filter(query_filter).only(
-            *_COMIC_ONLY_FIELDS
-        )
+        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:
-            defaults = {"comic": comic}
-            defaults.update(updates)
-            for key, value in search_kwargs.items():
-                if not key.startswith("comic"):
-                    defaults[key] = value
-
-            bm = Bookmark(**defaults)
+            bm = Bookmark(comic=comic, **auth_filter, **updates)
             create_bookmarks.append(bm)
         count = len(create_bookmarks)
         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
 
@@ -143,22 +131,20 @@ class BookmarkUpdate(GroupACLMixin, BookmarkSearchMixin):
         try:
             UserActive.objects.update_or_create(user=user)
         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_filter, updates, log):
+    def update_bookmarks(cls, auth_filter, comic_pks, updates, log):
         """Update a user bookmark."""
-        search_kwargs = cls.get_bookmark_search_kwargs(auth_filter, comic_filter)
-
         user = None
         for key, value in auth_filter.items():
             if key == "user":
                 user = User.objects.get(pk=value)
             break
 
-        count = cls._update_bookmarks(search_kwargs, updates, user)
-        count += cls._create_bookmarks(comic_filter, search_kwargs, updates, user)
+        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)
         if count:

codex/librarian/covers/create.py

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

codex/librarian/covers/path.py

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

codex/librarian/covers/purge.py

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

codex/librarian/cron/crond.py

@@ -28,7 +28,7 @@ class CronThread(NamedThread):
         self._stop_event = Event()
         self._cond = Condition()
         self._task_times = ()
-        super().__init__(*args, name=self.__class__.__name__, daemon=True, **kwargs)
+        super().__init__(*args, daemon=True, **kwargs)
 
     def _create_task_times(self):
         task_times = {}

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

@@ -94,7 +94,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)
@@ -147,7 +147,7 @@ class ExtractMetadataImporter(QueryForeignKeysImporter):
     @staticmethod
     def _clean_charfield(model, field_name, value):
         try:
-            field: CharField = model._meta.get_field(field_name)  # type: ignore
+            field: CharField = model._meta.get_field(field_name)  # type: ignore[reportAssignmentType]
             if value:
                 value = value[: field.max_length].strip()
             if not value:

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

@@ -43,7 +43,9 @@ 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.")

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}")

codex/librarian/importer/link_comics.py

@@ -186,7 +186,8 @@ class LinkComicsImporter(LinkCoversImporter):
         return tms, all_del_pks
 
     def bulk_fix_comic_m2m_field(self, field_name, m2m_links, status):
-        """Recreate an m2m field for a set of comics.
+        """
+        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: