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

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

@@ -96,7 +96,7 @@ class QueryForeignKeysImporter(QueryCustomCoversImporter):
         if extra_fields:
             fields += extra_fields
         flat = len(fields) == 1 and fk_cls != Publisher
-        qs = fk_cls.objects.filter(fk_filter).values_list(*fields, flat=flat)
+        qs = fk_cls.objects.filter(fk_filter).distinct().values_list(*fields, flat=flat)
         return frozenset(qs)
 
     def _query_create_metadata(  # noqa: PLR0913
@@ -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
@@ -449,7 +447,7 @@ class QueryForeignKeysImporter(QueryCustomCoversImporter):
 
         # Build combined query object from the value_filter
         model = DICT_MODEL_FIELD_MODEL_MAP[field_name]
-        if model == Identifier:
+        if model in (Identifier, Contributor):
             for filter_and_prefix, value_filter in query_filter_map.items():
                 self._query_create_metadata(
                     model,
@@ -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():
@@ -149,7 +149,10 @@ class Janitor(
                     for next_task in next_tasks:
                         self.librarian_queue.put(next_task)
                 case JanitorSearchOptimizeFinishedTask():
-                    next_tasks = (JanitorVacuumTask(), JanitorBackupTask())
+                    next_tasks = (
+                        JanitorVacuumTask(),
+                        JanitorBackupTask(),
+                    )
                     for next_task in next_tasks:
                         self.librarian_queue.put(next_task)
                 case _:

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:
@@ -121,7 +121,7 @@ class LibrarianDaemon(Process, LoggerBaseMixin):
             case DelayedTasks():
                 self._threads.delayed_tasks_thread.queue.put(task)
             case LibrarianShutdownTask():
-                self.log.info(f"Shutting down {self.__class__.__name__}...")
+                self.log.info(f"Shutting down {self.name}...")
                 self.run_loop = False
             case _:
                 self.log.warning(f"Unhandled Librarian task: {task}")
@@ -150,34 +150,34 @@ class LibrarianDaemon(Process, LoggerBaseMixin):
 
     def _start_threads(self):
         """Start all librarian's threads."""
-        self.log.debug(f"{self.__class__.__name__} starting all threads.")
+        self.log.debug(f"{self.name} starting all threads.")
         for thread in self._threads:
             thread.start()
-        self.log.info(f"{self.__class__.__name__} started all threads.")
+        self.log.info(f"{self.name} started all threads.")
 
     def _startup(self):
         """Initialize threads."""
         self.init_logger(self.log_queue)
-        self.log.debug(f"Started {self.__class__.__name__}.")
+        self.log.debug(f"Started {self.name}.")
         self.janitor = Janitor(self.log_queue, self.queue)
         self._create_threads()  # can't do this in init.
         self._start_threads()
         self.run_loop = True
-        self.log.info(f"{self.__class__.__name__} ready for tasks.")
+        self.log.info(f"{self.name} ready for tasks.")
 
     def _stop_threads(self):
         """Stop all librarian's threads."""
-        self.log.debug(f"{self.__class__.__name__} stopping all threads...")
+        self.log.debug(f"{self.name} stopping all threads...")
         for thread in self._reversed_threads:
             thread.stop()
-        self.log.debug(f"{self.__class__.__name__} stopped all threads.")
+        self.log.debug(f"{self.name} stopped all threads.")
 
     def _join_threads(self):
         """Join all librarian threads."""
-        self.log.debug(f"{self.__class__.__name__} joining all threads...")
+        self.log.debug(f"{self.name} joining all threads...")
         for thread in self._reversed_threads:
             thread.join()
-        self.log.info(f"{self.__class__.__name__} joined all threads.")
+        self.log.info(f"{self.name} joined all threads.")
 
     def _shutdown(self):
         """Shutdown threads and queues."""
@@ -188,12 +188,13 @@ class LibrarianDaemon(Process, LoggerBaseMixin):
             self.queue.get_nowait()
         self.queue.close()
         self.queue.join_thread()
-        self.log.info(f"{self.__class__.__name__} finished.")
+        self.log.info(f"{self.name} finished.")
         self.log_queue.close()
         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.
@@ -205,11 +206,11 @@ class LibrarianDaemon(Process, LoggerBaseMixin):
                     task = self.queue.get()
                     self._process_task(task)
                 except Exception:
-                    self.log.exception(f"In {self.__class__.__name__} loop")
+                    self.log.exception(f"In {self.name} loop")
         except Exception:
-            self.log.exception(f"{self.__class__.__name__} crashed.")
+            self.log.exception(f"{self.name} crashed.")
         except KeyboardInterrupt:
-            self.log.debug(f"{self.__class__.__name__} Keyboard interrupt")
+            self.log.debug(f"{self.name} Keyboard interrupt")
         finally:
             self._shutdown()
 

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

@@ -114,7 +114,7 @@ class FTSUpdateMixin(RemoveMixin):
             return ""
         return ",".join((iso_code, field_instance.to_representation(iso_code)))
 
-    def _get_comicts_fts_list(
+    def _get_comics_fts_list(
         self, comics, country_field, language_field, obj_list, create
     ):
         """Prepare a batch of search entries."""
@@ -157,14 +157,15 @@ class FTSUpdateMixin(RemoveMixin):
             if create:
                 comicfts.created_at = now
             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()
         obj_list = []
         comics = self._annotate_fts_query(comics)
-        self._get_comicts_fts_list(
+        self._get_comics_fts_list(
             comics, country_field, language_field, obj_list, create
         )
         return obj_list
@@ -177,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:
@@ -205,11 +206,14 @@ class FTSUpdateMixin(RemoveMixin):
                 batch_start = time()
                 batch_to = batch_from + SEARCH_INDEX_BATCH_SIZE
                 comics_batch = comics_qs[batch_from:batch_to]
-
+                self.log.debug(
+                    f"Checking {comics_batch.count()}/{count} comics for search index operations..."
+                )
                 if self.abort_event.is_set():
                     break
                 operate_comicfts = self._get_comicfts_list(comics_batch, create)
                 operate_comicfts_count = len(operate_comicfts)
+                self.log.debug(f"{verb}ing {operate_comicfts_count} search entries...")
                 if self.abort_event.is_set():
                     break
                 if create:
@@ -223,7 +227,7 @@ class FTSUpdateMixin(RemoveMixin):
                 batch_time = time() - batch_start
                 eps = round(count / batch_time)
                 self.log.debug(
-                    f"{verb} {count}/{operate_comicfts_count} search entries in {batch_time}, {eps} per second."
+                    f"{verb} {operate_comicfts_count}/{count} search entries in {batch_time}, {eps} per second."
                 )
                 batch_from = batch_to
         finally:
@@ -281,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

codex/librarian/watchdog/emitter.py

@@ -46,14 +46,14 @@ class DatabasePollingEmitter(EventEmitter, WorkerBaseMixin):
 
     _DIR_NOT_FOUND_TIMEOUT = 15 * 60
 
-    def __init__(  # noqa PLR0913
+    def __init__(  # noqa: PLR0913
         self,
         event_queue,
         watch,
         timeout=DEFAULT_EMITTER_TIMEOUT,
         log_queue=None,
         librarian_queue=None,
-        covers_only=False,
+        covers_only=False,  # noqa: FBT002
     ):
         """Initialize snapshot methods."""
         self.init_worker(log_queue, librarian_queue)
@@ -72,7 +72,7 @@ class DatabasePollingEmitter(EventEmitter, WorkerBaseMixin):
             # default stat and listdir params
         )
 
-    def poll(self, force=False):
+    def poll(self, force: bool):
         """Poll now, sooner than timeout."""
         self._force = force
         with self._poll_cond:
@@ -118,7 +118,7 @@ class DatabasePollingEmitter(EventEmitter, WorkerBaseMixin):
         return ok
 
     @property
-    def timeout(self) -> int | None:  # type: ignore
+    def timeout(self) -> int | None:  # type: ignore[reportIncompatibleMethodOverride]
         """Get the timeout for this emitter from its library."""
         # The timeout from the constructor, self._timeout, is thrown away in favor
         # of a dynamic timeout from the database.

codex/librarian/watchdog/event_batcherd.py

@@ -1,4 +1,5 @@
-"""Batch watchdog events into bulk database tasks.
+"""
+Batch watchdog events into bulk database tasks.
 
 Watchdog actually starts events as bulk events with the DirSnapshotDiff
 but the built-in filesystem event emitters serialize them, so the most

codex/librarian/watchdog/events.py

@@ -198,8 +198,7 @@ class CodexLibraryEventHandler(CodexEventHandlerBase):
                 task = WatchdogEventTask(self.library_pk, sub_event)
                 self.librarian_queue.put(task)
 
-            # Calls stub event dispatchers
-            # super().dispatch(event)
+            # Do not call super dispatch to call stub event dispatchers
         except Exception:
             self.log.exception(f"{self.__class__.__name__} dispatch")
 

codex/librarian/watchdog/observers.py

@@ -1,5 +1,6 @@
 """The Codex Library Watchdog Observer threads."""
 
+from watchdog.events import FileSystemEvent, FileSystemEventHandler
 from watchdog.observers import Observer
 from watchdog.observers.api import (
     DEFAULT_OBSERVER_TIMEOUT,
@@ -98,14 +99,16 @@ class UatuMixin(BaseObserver, WorkerBaseMixin):
         except Exception:
             self.log.exception(f"{self.__class__.__name__} sync library watches")
 
-    def schedule(  # type: ignore
+    def schedule(
         self,
-        event_handler,
-        path,
-        recursive=False,
-        _event_filter=None,
-    ):
-        """Override BaseObserver for Codex emitter class.
+        event_handler: FileSystemEventHandler,
+        path: str,
+        *,
+        recursive: bool = False,
+        event_filter: list[type[FileSystemEvent]] | None = None,  # noqa: ARG002, F841, RUF100
+    ) -> ObservedWatch:
+        """
+        Override BaseObserver for Codex emitter class.
 
         https://pythonhosted.org/watchdog/_modules/watchdog/observers/api.html#BaseObserver
         """
@@ -137,9 +140,11 @@ class UatuMixin(BaseObserver, WorkerBaseMixin):
 #     watchdog class structure doesn't work that way.
 
 
-class LibraryEventObserver(UatuMixin, Observer):  # type: ignore
+class LibraryEventObserver(UatuMixin, Observer):  # type: ignore[reportGeneralTypeIssues]
     """Regular observer."""
 
+    # Observer is a dynamically generated class by platform at runtime.
+
     ENABLE_FIELD = "events"
 
 
@@ -156,7 +161,7 @@ class LibraryPollingObserver(UatuMixin):
             *args, emitter_class=DatabasePollingEmitter, timeout=timeout, **kwargs
         )
 
-    def poll(self, library_pks, force=False):
+    def poll(self, library_pks, force: bool):
         """Poll each requested emitter."""
         try:
             qs = Library.objects.all()
@@ -165,7 +170,7 @@ class LibraryPollingObserver(UatuMixin):
             paths = frozenset(qs.values_list("path", flat=True))
 
             for emitter in self.emitters:
-                polling_emitter: DatabasePollingEmitter = emitter  # type: ignore
+                polling_emitter: DatabasePollingEmitter = emitter  # type: ignore[reportAssignmentType]
                 if emitter.watch.path in paths:
                     polling_emitter.poll(force)
         except Exception: