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

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

@@ -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:

codex/librarian/importer/moved.py

@@ -46,9 +46,7 @@ class MovedImporter(AggregateMetadataImporter):
             new_path = self.task.files_moved[comic.path]
             comic.path = new_path
             new_path = Path(new_path)
-            comic.parent_folder = Folder.objects.get(  # type: ignore
-                path=new_path.parent
-            )
+            comic.parent_folder = Folder.objects.get(path=new_path.parent)
             comic.updated_at = Now()
             comic.presave()
             folder_m2m_links[comic.pk] = Folder.objects.filter(
@@ -137,7 +135,7 @@ class MovedImporter(AggregateMetadataImporter):
                     f"Unlinked {len(unlink_groups)} {model.__name__} moved custom covers."
                 )
 
-        self._remove_covers(unlink_pks, custom=True)  # type: ignore
+        self._remove_covers(unlink_pks, custom=True)
 
     def _bulk_covers_moved(self, status=None):
         """Move covers."""
@@ -194,8 +192,6 @@ class MovedImporter(AggregateMetadataImporter):
             folder.updated_at = Now()
             update_folders.append(folder)
 
-        # delete_folders = Folder.objects.filter(library=self.library, path__in=new_paths)
-
         update_folders = sorted(update_folders, key=lambda x: len(Path(x.path).parts))
 
         Folder.objects.bulk_update(update_folders, MOVED_BULK_FOLDER_UPDATE_FIELDS)
@@ -212,7 +208,6 @@ class MovedImporter(AggregateMetadataImporter):
         """Move folders under existing folders."""
         while True:
             # Get existing parent folders
-            # dest_parent_paths = tuple(str(path) for path in dest_parent_folder_paths_map)
             dest_parent_paths = tuple(dest_parent_folder_paths_map.keys())
             extant_parent_folders = Folder.objects.filter(
                 library=self.library, path__in=dest_parent_paths

codex/librarian/importer/query_fks.py

@@ -229,9 +229,7 @@ class QueryForeignKeysImporter(QueryCustomCoversImporter):
 
         group_filter = Q()
         for group_tree, count_value in update_group_trees.items():
-            compare_filter = {}
-            for field_name, value in zip(compare_fields, group_tree, strict=False):
-                compare_filter[field_name] = value
+            compare_filter = dict(zip(compare_fields, group_tree, strict=False))
             compare_filter[count_field_name] = count_value
             group_filter |= Q(**compare_filter)
         return group_filter
@@ -494,7 +492,6 @@ class QueryForeignKeysImporter(QueryCustomCoversImporter):
 
     def _query_missing_simple_models(self, names, fk_data, status):
         """Find missing named models and folders."""
-        # count = 0
         if not names:
             return 0
         create_fks, base_cls, field, fk_field = fk_data

codex/librarian/importer/tasks.py

@@ -18,7 +18,7 @@ class ImportDBDiffTask(ImportTask):
 
     dirs_moved: Mapping[str, str] = field(default_factory=dict)
     dirs_modified: frozenset[str] = frozenset()
-    # dirs_created: frozenset[str] | None = frozenset()
+    # dirs_created: frozenset[str] | None = frozenset() # noqa: ERA001
     dirs_deleted: frozenset[str] = frozenset()
 
     files_moved: Mapping[str, str] = field(default_factory=dict)

codex/librarian/janitor/integrity.py

@@ -2,6 +2,7 @@
 # Uses app.get_model() because functions may also be called before the models are ready on startup.
 
 import re
+from typing import TYPE_CHECKING
 
 from django.apps import apps
 from django.db import DEFAULT_DB_ALIAS, connections
@@ -19,6 +20,13 @@ from codex.settings.settings import (
 from codex.status import Status
 from codex.worker_base import WorkerBaseMixin
 
+if TYPE_CHECKING:
+    from django.db.models.manager import BaseManager
+
+    from codex.models.base import BaseModel
+    from codex.models.comic import Comic
+
+
 REPAIR_FLAG_PATH = CONFIG_PATH / "rebuild_db"
 REBUILT_DB_PATH = DB_PATH.parent / (DB_PATH.name + ".rebuilt")
 BACKUP_DB_PATH = DB_PATH.parent / (DB_PATH.name + ".bak")
@@ -105,7 +113,7 @@ def _null_bad_fk_rels_table(table_name, bad_rows, log):
     fields = model._meta.fields
     field_names = {}
     update_objs = []
-    objs = model.objects.filter(pk__in=bad_rows.keys())
+    objs: BaseManager[BaseModel] = model.objects.filter(pk__in=bad_rows.keys())  # type: ignore[reportAssignmentType]
     update_fields = {"updated_at"}
     now = Now()
     for obj in objs:
@@ -119,7 +127,7 @@ def _null_bad_fk_rels_table(table_name, bad_rows, log):
                 field_name = field_names[fkid]
                 setattr(obj, field_name, None)
                 update_fields.add(field_name)
-            obj.updated_at = now  # type: ignore
+            obj.updated_at = now
             update_objs.append(obj)
         except Exception as exc:
             log.warning(
@@ -142,10 +150,10 @@ def _null_bad_fk_rels(bad_fk_rels, log):
     for table_name, bad_rows in bad_fk_rels.items():
         try:
             fix_comic_pks |= _null_bad_fk_rels_table(table_name, bad_rows, log)
-        except Exception as exc:
+        except Exception:
             pks = sorted(bad_rows.keys())
-            log.error(  # noqa: TRY400
-                f"Unable to null {len(pks)} {table_name} rows with bad foreign keys - {exc}"
+            log.exception(
+                f"Unable to null {len(pks)} {table_name} rows with bad foreign keys"
             )
             log.error(f"{table_name}: {pks}")  # noqa: TRY400
     return fix_comic_pks
@@ -175,10 +183,8 @@ def _delete_bad_m2m_rows(bad_m2m_rows, log):
     for table_name, ids in bad_m2m_rows.items():
         try:
             count += _delete_bad_m2m_rows_table(table_name, ids, fix_comic_pks, log)
-        except Exception as exc:
-            log.error(  # noqa: TRY400
-                f"Could not delete bad foreign keys in table {table_name} - {exc}"
-            )
+        except Exception:
+            log.exception(f"Could not delete bad foreign keys in table {table_name}")
     if count:
         log.info(f"Removed {count} bad foreign key relations.")
     return fix_comic_pks
@@ -189,7 +195,9 @@ def _mark_comics_for_update(fix_comic_pks, log):
     if not fix_comic_pks:
         return
     comic_model = apps.get_model(app_label="codex", model_name="comic")
-    outdated_comics = comic_model.objects.filter(pk__in=fix_comic_pks).only(
+    outdated_comics: BaseManager[Comic] = comic_model.objects.filter(
+        pk__in=fix_comic_pks
+    ).only(  # type: ignore[reportAssignmentType]
         "stat", "updated_at"
     )
     if not outdated_comics:
@@ -198,12 +206,12 @@ def _mark_comics_for_update(fix_comic_pks, log):
     update_comics = []
     now = Now()
     for comic in outdated_comics:
-        stat_list = comic.stat  # type: ignore
+        stat_list = comic.stat
         if not stat_list:
             continue
         stat_list[8] = 0.0
-        comic.stat = stat_list  # type: ignore
-        comic.updated_at = now  # type: ignore
+        comic.stat = stat_list  # type: ignore[reportAttributeAccessIssue]
+        comic.updated_at = now
         update_comics.append(comic)
 
     if update_comics:
@@ -227,8 +235,8 @@ def fix_foreign_keys(log=None):
     fix_comic_pks |= _delete_bad_m2m_rows(bad_m2m_rows, log)
     try:
         _mark_comics_for_update(fix_comic_pks, log)
-    except Exception as exc:
-        LOG.warning(f"Could not mark comics with bad relations for update: {exc}")
+    except Exception:
+        LOG.exception("Could not mark comics with bad relations for update")
 
 
 def _repair_extra_custom_cover_libraries(library_model, log):
@@ -277,7 +285,7 @@ def _is_integrity_ok(results):
     )
 
 
-def integrity_check(long=True, log=None):
+def integrity_check(long, log=None):
     """Run sqlite3 integrity check."""
     if not log:
         log = LOG
@@ -318,9 +326,8 @@ def fts_integrity_check(log=None):
         if results:
             # I'm not sure if this raises or puts the error in the results.
             raise ValueError(results)  # noqa: TRY301
-    except Exception as exc:
-        log.warning("Full Text Search Index failed integrity check.")
-        log.warning(exc)
+    except Exception:
+        log.exception("Full Text Search Index failed integrity check.")
     else:
         log.info("Full Text Search Index passed integrity check.")
         success = True
@@ -340,7 +347,7 @@ class IntegrityMixin(WorkerBaseMixin):
         finally:
             self.status_controller.finish(status)
 
-    def integrity_check(self, long=False):
+    def integrity_check(self, long: bool):
         """Integrity check task."""
         subtitle = "" if long else "Quick"
         status = Status(JanitorStatusTypes.INTEGRITY_CHECK, subtitle=subtitle)

codex/librarian/janitor/janitor.py

@@ -109,7 +109,7 @@ class Janitor(
                 case JanitorVacuumTask():
                     self.vacuum_db()
                 case JanitorBackupTask():
-                    self.backup_db()
+                    self.backup_db(show_status=True)
                 case JanitorLatestVersionTask():
                     self.update_latest_version(task.force)
                 case JanitorUpdateTask():

codex/librarian/janitor/latest_version.py

@@ -28,7 +28,7 @@ class LatestVersionMixin(WorkerBaseMixin):
         response = requests.get(_REPO_URL, timeout=_REPO_TIMEOUT)
         return json.loads(response.text)["info"]["version"]
 
-    def update_latest_version(self, force=False):
+    def update_latest_version(self, force: bool):
         """Get the latest version from a remote repo using a cache."""
         status = Status(JanitorStatusTypes.CODEX_LATEST_VERSION)
         try:

codex/librarian/janitor/update.py

@@ -27,7 +27,7 @@ class UpdateMixin(WorkerBaseMixin):
         versio_latest_version = Version(latest_version)
 
         installed_versio_version = Version(VERSION)
-        if versio_latest_version.parts[1] and not installed_versio_version.parts[1]:  # type: ignore
+        if versio_latest_version.parts[1] and not installed_versio_version.parts[1]:  # type: ignore[reportIndexIssue]
             pre_blurb = "latest version is a prerelease. But installed version is not."
         else:
             result = versio_latest_version > installed_versio_version
@@ -35,7 +35,7 @@ class UpdateMixin(WorkerBaseMixin):
         self.log.debug(f"{latest_version=} > {VERSION=} = {result}{pre_blurb}")
         return result
 
-    def update_codex(self, force=False):
+    def update_codex(self, force: bool):
         """Update the package and restart everything if the version changed."""
         status = Status(JanitorStatusTypes.CODEX_UPDATE)
         try:

codex/librarian/janitor/vacuum.py

@@ -30,7 +30,7 @@ class VacuumMixin(WorkerBaseMixin):
         finally:
             self.status_controller.finish(status)
 
-    def backup_db(self, backup_path=BACKUP_DB_PATH, show_status=True):
+    def backup_db(self, show_status: bool, backup_path=BACKUP_DB_PATH):
         """Backup the database."""
         status = Status(JanitorStatusTypes.DB_BACKUP) if show_status else ""
         try:

codex/librarian/librariand.py

@@ -79,7 +79,7 @@ class LibrarianDaemon(Process, LoggerBaseMixin):
         startup_tasks = (
             AdoptOrphanFoldersTask(),
             WatchdogSyncTask(),
-            SearchIndexUpdateTask(False),
+            SearchIndexUpdateTask(rebuild=False),
         )
 
         for task in startup_tasks:
@@ -193,7 +193,8 @@ class LibrarianDaemon(Process, LoggerBaseMixin):
         self.log_queue.join_thread()
 
     def run(self):
-        """Process tasks from the queue.
+        """
+        Process tasks from the queue.
 
         This process also runs the crond thread and the Watchdog Observer
         threads.

codex/librarian/notifier/notifierd.py

@@ -16,7 +16,8 @@ class NotifierThread(AggregateMessageQueuedThread):
         self.cache[item.text] = item
 
     def _send_task(self, task):
-        """Send a group_send message to the mulitprocess broadcast channel.
+        """
+        Send a group_send message to the mulitprocess broadcast channel.
 
         A random consumer awaiting the broadcast channel will consume it,
         and do a group_send with it's message.

codex/librarian/search/optimize.py

@@ -22,7 +22,7 @@ class OptimizeMixin(QueuedThread):
         self.abort_event = abort_event
         super().__init__(*args, **kwargs)
 
-    def optimize(self, janitor=False):
+    def optimize(self, janitor: bool):
         """Remove records not in the database from the index, trapping exceptions."""
         start_time = time()
         status = Status(SearchIndexStatusTypes.SEARCH_INDEX_OPTIMIZE)

codex/librarian/search/remove.py

@@ -21,7 +21,7 @@ class RemoveMixin(OptimizeMixin):
         self.status_controller.finish(clear_status)
         self.log.info("Old search index cleared.")
 
-    def _remove_stale_records(self, status):  # type: ignore
+    def _remove_stale_records(self, status):
         """Remove records not in the database from the index."""
         start_time = time()
         delete_comicfts = ComicFTS.objects.filter(comic__isnull=True)

codex/librarian/search/update.py

@@ -14,7 +14,7 @@ from codex.librarian.search.status import SearchIndexStatusTypes
 from codex.models import Comic, Library
 from codex.models.comic import ComicFTS
 from codex.models.functions import GroupConcat
-from codex.serializers.fields import CountryField, LanguageField, PyCountryField
+from codex.serializers.fields.browser import CountryField, LanguageField, PyCountryField
 from codex.settings.settings import SEARCH_INDEX_BATCH_SIZE
 from codex.status import Status
 
@@ -159,7 +159,7 @@ class FTSUpdateMixin(RemoveMixin):
             obj_list.append(comicfts)
             self.log.debug(f"{len(obj_list)}/{comics.count()} entries prepped.")
 
-    def _get_comicfts_list(self, comics, create=False):
+    def _get_comicfts_list(self, comics, create: bool):
         """Create a ComicFTS object for bulk_create or bulk_update."""
         country_field = CountryField()
         language_field = LanguageField()
@@ -178,7 +178,7 @@ class FTSUpdateMixin(RemoveMixin):
             self.log.debug(f"{verb} no search entries.")
         self.status_controller.finish(status)
 
-    def _update_search_index_operate(self, comics_qs, create=False):
+    def _update_search_index_operate(self, comics_qs, create: bool):
         count = comics_qs.count()
         verb = "create" if create else "update"
         if not count:
@@ -285,7 +285,7 @@ class FTSUpdateMixin(RemoveMixin):
         elapsed = naturaldelta(elapsed_time)
         self.log.info(f"Search index updated in {elapsed}.")
 
-    def update_search_index(self, rebuild=False):
+    def update_search_index(self, rebuild: bool):
         """Update or Rebuild the search index."""
         start_time = time()
         self.abort_event.clear()

codex/librarian/telemeter/stats.py

@@ -62,11 +62,12 @@ class CodexStats:
         request_model_set = self.params.get(key, {})
         all_models = _KEY_MODELS_MAP[key]
         if request_model_set:
-            models = []
-            for model_name in request_model_set:
-                for model in all_models:
-                    if model.__name__.lower() == model_name.lower():
-                        models.append(model)
+            models = [
+                model
+                for model in all_models
+                for model_name in request_model_set
+                if model.__name__.lower() == model_name.lower()
+            ]
         else:
             models = all_models
         return tuple(models)
@@ -149,7 +150,7 @@ class CodexStats:
 
     def _add_file_types(self, obj):
         """Query for file types."""
-        if self.params and "fileTypes" not in self.params:
+        if self.params and "file_types" not in self.params:
             return
         file_types = {}
         qs = (

codex/librarian/telemeter/telemeter.py

@@ -68,7 +68,6 @@ def _send_telemetry(log):
     stats = CodexStats().get()
     data = {"stats": stats, "uuid": ts.version}
     _post_stats(log, data)
-    # log.debug("Sent anonymous stats")
     ts.save()  # update updated_at
 
 

codex/librarian/watchdog/db_snapshot.py

@@ -61,12 +61,12 @@ class CodexDatabaseSnapshot(DirectorySnapshot, LoggerBaseMixin):
     def __init__(
         self,
         path,
-        _recursive=True,  # unused, always recursive
+        _recursive=True,  # noqa: FBT002 unused, always recursive
         stat=os.stat,
         _listdir=os.listdir,  # unused for database
-        force=False,
+        force=False,  # noqa: FBT002
         log_queue=None,
-        covers_only=False,
+        covers_only=False,  # noqa: FBT002
     ):
         """Initialize like DirectorySnapshot but use a database walk."""
         self._covers_only = covers_only

codex/librarian/watchdog/dir_snapshot_diff.py

@@ -33,7 +33,8 @@ class CodexDirectorySnapshotDiff(DirectorySnapshotDiff):
         return self._get_inode(data.ref, path) == self._get_inode(data.snapshot, path)
 
     def _is_stats_equal(self, data, old_path, new_path):
-        """Return if the mtime and size are equal.
+        """
+        Return if the mtime and size are equal.
 
         For old paths in the ref and new paths in the snapshot.
         """
@@ -84,9 +85,7 @@ class CodexDirectorySnapshotDiff(DirectorySnapshotDiff):
             if not self._is_stats_equal(data, old_path, new_path):
                 data.modified.add(new_path)
 
-    def __init__(  # C901, PLR0912
-        self, ref, snapshot, ignore_device=False, inode_only_modified=False
-    ):
+    def __init__(self, ref, snapshot, ignore_device: bool, inode_only_modified: bool):
         """Create diff object."""
         self._ignore_device = ignore_device
         self._inode_only_modified = inode_only_modified