codex 1.8.0a2__py3-none-any.whl → 1.8.0a4__py3-none-any.whl

codex/choices/admin.py

@@ -118,23 +118,23 @@ ADMIN_TASK_GROUPS: MappingProxyType[
                     {
                         "value": "db_fts_rebuild",
                         "title": "Repair Search Index",
-                        "desc": "Probably faster than Rebuild if integrity check fails.",
+                        "desc": "Probably faster than Rebuild if the integrity check fails.",
                     },
                     {
                         "value": "search_index_abort",
-                        "title": "Abort Legacy Search Index Sync",
+                        "title": "Abort Search Index Sync",
                         "desc": "Aborts search index sync tasks.",
                     },
                     {
                         "value": "search_index_update",
                         "title": "Sync Search Index",
-                        "desc": "with recently changed comics. This should not need to be run.",
+                        "desc": "with recently changed comics.",
                         "confirm": "This can take a long time",
                     },
                     {
                         "value": "search_index_rebuild",
                         "title": "Rebuild Search Index Using Sync.",
-                        "desc": "Delete and rebuild the search index from scratch using the legacy syncer. This should not need to be run.",
+                        "desc": "Delete and rebuild the search index from scratch using the syncer.",
                         "confirm": "This can take a long time",
                     },
                 ),

codex/choices/statii.py

@@ -8,11 +8,11 @@ from codex.librarian.covers.status import COVERS_STATII
 from codex.librarian.restarter.status import RESTARTER_STATII
 from codex.librarian.scribe.importer.statii.create import CREATE_STATII
 from codex.librarian.scribe.importer.statii.delete import REMOVE_STATII
+from codex.librarian.scribe.importer.statii.failed import FAILED_IMPORTS_STATII
 from codex.librarian.scribe.importer.statii.link import LINK_STATII
 from codex.librarian.scribe.importer.statii.query import QUERY_STATII
 from codex.librarian.scribe.importer.statii.read import READ_STATII
 from codex.librarian.scribe.importer.statii.search import IMPORTER_SEARCH_INDEX_STATII
-from codex.librarian.scribe.importer.status import FAILED_IMPORTS_STATII
 from codex.librarian.scribe.janitor.status import JANITOR_STATII
 from codex.librarian.scribe.search.status import SEARCH_INDEX_STATII
 from codex.librarian.scribe.status import SCRIBE_STATII

codex/librarian/covers/status.py

@@ -23,7 +23,7 @@ class RemoveCoversStatus(CoversStatus):
 
     CODE = "CRC"
     VERB = "Remove"
-    LOG_SUCCESS = True
+    log_success = True
 
 
 class FindOrphanCoversStatus(CoversStatus):

codex/librarian/librariand.py

@@ -21,6 +21,7 @@ from codex.librarian.restarter.restarter import CodexRestarter
 from codex.librarian.restarter.tasks import CodexRestarterTask
 from codex.librarian.scribe.janitor.tasks import JanitorAdoptOrphanFoldersTask
 from codex.librarian.scribe.scribed import ScribeThread
+from codex.librarian.scribe.search.tasks import SearchIndexSyncTask
 from codex.librarian.scribe.tasks import ScribeTask
 from codex.librarian.tasks import LibrarianShutdownTask, WakeCronTask
 from codex.librarian.watchdog.event_batcherd import WatchdogEventBatcherThread
@@ -63,6 +64,7 @@ class LibrarianDaemon(Process):
         startup_tasks = (
             JanitorAdoptOrphanFoldersTask(),
             WatchdogSyncTask(),
+            SearchIndexSyncTask(),
         )
 
         for task in startup_tasks:

codex/librarian/scribe/importer/const.py

@@ -359,3 +359,11 @@ ALL_COMIC_GROUP_FIELD_NAMES = (
     "story_arc_numbers",
     "folders",
 )
+
+##########
+# Failed #
+##########
+UPDATE_FIS = "update_fis"
+CREATE_FIS = "create_fis"
+DELETE_FI_PATHS = "delete_fi_paths"
+BULK_UPDATE_FAILED_IMPORT_FIELDS = ("name", "stat", "updated_at")

codex/librarian/scribe/importer/create/foreign_keys.py

@@ -174,7 +174,7 @@ class CreateForeignKeysCreateUpdateImporter(CreateForeignKeysFolderImporter):
         self.status_controller.update(status)
         key_args_map, update_args_map = MODEL_CREATE_ARGS_MAP[model]
         update_objs = []
-        update_tuples = sorted(update_tuples, key=lambda t: str(t))
+        update_tuples = sorted(update_tuples, key=str)
         fts_update_pks = set()
         for values_tuple in update_tuples:
             key_args, update_args = self._get_create_update_args(

codex/librarian/scribe/importer/delete/covers.py

@@ -16,7 +16,9 @@ class DeletedCoversImporter(SearchIndexImporter):
 
     def bulk_covers_deleted(self, **kwargs):
         """Bulk delete comics found missing from the filesystem."""
-        status = ImporterRemoveCoversStatus(0, len(self.task.covers_deleted))
+        status = ImporterRemoveCoversStatus(
+            0, len(self.task.covers_deleted), log_success=False
+        )
         try:
             if not self.task.covers_deleted:
                 return 0

codex/librarian/scribe/importer/failed/__init__.py

@@ -0,0 +1 @@
+"""Failed imports."""

codex/librarian/scribe/importer/failed/create.py

@@ -0,0 +1,97 @@
+"""Update and create failed imports."""
+
+from django.db.models.functions import Now
+
+from codex.librarian.scribe.importer.const import (
+    BULK_UPDATE_FAILED_IMPORT_FIELDS,
+    CREATE_FIS,
+    UPDATE_FIS,
+)
+from codex.librarian.scribe.importer.failed.query import FailedImportsQueryImporter
+from codex.librarian.scribe.importer.statii.failed import (
+    ImporterFailedImportsCreateStatus,
+    ImporterFailedImportsUpdateStatus,
+)
+from codex.models import FailedImport
+
+
+class FailedImportsCreateUpdateImporter(FailedImportsQueryImporter):
+    """Methods for failed imports."""
+
+    def _bulk_update_failed_imports(
+        self, status: ImporterFailedImportsUpdateStatus | None
+    ):
+        """Bulk update failed imports."""
+        update_failed_imports = self.metadata.pop(UPDATE_FIS, None)
+        try:
+            if not update_failed_imports:
+                return
+            if status:
+                self.status_controller.start(status)
+            update_failed_import_objs = FailedImport.objects.filter(
+                library=self.library, path__in=update_failed_imports.keys()
+            ).only(*BULK_UPDATE_FAILED_IMPORT_FIELDS)
+            if not update_failed_import_objs:
+                return
+            for fi in update_failed_import_objs:
+                try:
+                    exc = update_failed_imports.pop(fi.path)
+                    fi.set_reason(exc)
+                    fi.updated_at = Now()
+                    fi.presave()
+                except OSError as exc:
+                    self.log.warning(f"Presaving failed import {fi.path}: {exc}")
+                except Exception:
+                    self.log.exception(
+                        f"Error preparing failed import update for {fi.path}"
+                    )
+
+            FailedImport.objects.bulk_update(
+                update_failed_import_objs, fields=BULK_UPDATE_FAILED_IMPORT_FIELDS
+            )
+            count = len(update_failed_import_objs)
+            level = "INFO" if count else "DEBUG"
+            self.log.log(level, f"Updated {count} old failed imports.")
+        finally:
+            self.status_controller.finish(status)
+
+    def _bulk_create_failed_imports(
+        self, status: ImporterFailedImportsCreateStatus | None
+    ):
+        """Bulk create failed imports."""
+        create_failed_imports = self.metadata.pop(CREATE_FIS, None)
+        try:
+            if not create_failed_imports:
+                return 0
+            if status:
+                self.status_controller.start(status)
+            create_objs = []
+            for path, exc in create_failed_imports.items():
+                try:
+                    fi = FailedImport(
+                        library=self.library, path=path, parent_folder=None
+                    )
+                    fi.set_reason(exc)
+                    create_objs.append(fi)
+                    fi.presave()
+                except OSError:
+                    self.log.warning(
+                        f"Error preparing failed import create for {path}: {exc}"
+                    )
+                except Exception:
+                    self.log.exception(
+                        f"Error preparing failed import create for {path}"
+                    )
+            count = len(create_objs)
+            if count:
+                FailedImport.objects.bulk_create(
+                    create_objs,
+                    update_conflicts=True,
+                    update_fields=BULK_UPDATE_FAILED_IMPORT_FIELDS,
+                    unique_fields=FailedImport._meta.unique_together[0],
+                )
+            level = "INFO" if count else "DEBUG"
+            self.log.log(level, f"Added {count} comics to failed imports.")
+        finally:
+            self.status_controller.finish(status)
+        return count

codex/librarian/scribe/importer/failed/failed.py

@@ -0,0 +1,54 @@
+"""Update and create failed imports."""
+
+from codex.librarian.scribe.importer.const import DELETE_FI_PATHS
+from codex.librarian.scribe.importer.failed.create import (
+    FailedImportsCreateUpdateImporter,
+)
+from codex.librarian.scribe.importer.statii.failed import (
+    ImporterFailedImportsDeleteStatus,
+)
+from codex.models import FailedImport
+
+
+class FailedImportsImporter(FailedImportsCreateUpdateImporter):
+    """Methods for failed imports."""
+
+    def _bulk_cleanup_failed_imports(
+        self, status: ImporterFailedImportsDeleteStatus | None
+    ):
+        """Remove FailedImport objects that have since succeeded."""
+        delete_failed_imports_paths = self.metadata.pop(DELETE_FI_PATHS, None)
+        try:
+            if not delete_failed_imports_paths:
+                return 0
+            if status:
+                self.status_controller.start(status)
+            # Cleanup FailedImports that were actually successful
+            qs = FailedImport.objects.filter(library=self.library).filter(
+                path__in=delete_failed_imports_paths
+            )
+            count, _ = qs.delete()
+            level = "INFO" if count else "DEBUG"
+            self.log.log(
+                level, f"Cleaned up {count} failed imports from {self.library.path}"
+            )
+            return count
+        finally:
+            self.status_controller.finish(status)
+
+    def fail_imports(self):
+        """Handle failed imports."""
+        created_count = 0
+        update_status = create_status = delete_status = None
+        try:
+            update_status, create_status, delete_status = self._query_failed_imports()
+            self._bulk_update_failed_imports(update_status)
+            created_count += self._bulk_create_failed_imports(create_status)
+            self._bulk_cleanup_failed_imports(delete_status)
+        except Exception:
+            self.log.exception("Processing failed imports")
+        finally:
+            self.status_controller.finish_many(
+                (update_status, create_status, delete_status)
+            )
+        self.counts.failed_imports = created_count

codex/librarian/scribe/importer/failed/query.py

@@ -0,0 +1,103 @@
+"""Update and create failed imports."""
+
+from pathlib import Path
+
+from codex.librarian.scribe.importer.const import (
+    CREATE_FIS,
+    DELETE_FI_PATHS,
+    FIS,
+    UPDATE_FIS,
+)
+from codex.librarian.scribe.importer.delete import DeletedImporter
+from codex.librarian.scribe.importer.statii.failed import (
+    ImporterFailedImportsCreateStatus,
+    ImporterFailedImportsDeleteStatus,
+    ImporterFailedImportsQueryStatus,
+    ImporterFailedImportsUpdateStatus,
+)
+from codex.models import Comic, FailedImport
+
+
+class FailedImportsQueryImporter(DeletedImporter):
+    """Methods for failed imports."""
+
+    def _query_failed_import_deletes(self, existing_failed_import_paths, new_fis_paths):
+        """Calculate Deletes."""
+        untouched_failed_import_paths = existing_failed_import_paths - frozenset(
+            new_fis_paths
+        )
+
+        qs = Comic.objects.filter(
+            library=self.library, path__in=untouched_failed_import_paths
+        ).only("path")
+        succeeded_failed_imports = frozenset(qs.values_list("path", flat=True))
+
+        possibly_missing_failed_import_paths = (
+            untouched_failed_import_paths - succeeded_failed_imports
+        )
+        missing_failed_import_paths = set()
+        for path in possibly_missing_failed_import_paths:
+            name = path.casefold()
+            # Case sensitive matching. exists() and is_file() are case insensitive.
+            # This will fail if there is a parent directory case mismatch.
+            # Rather than do a recursive solution, add it to missing if it fails.
+            try:
+                for path_obj in Path(path).parent.iterdir():
+                    if path_obj.name.casefold() == name:
+                        break
+                else:
+                    missing_failed_import_paths.add(path)
+            except FileNotFoundError:
+                missing_failed_import_paths.add(path)
+
+        return succeeded_failed_imports | missing_failed_import_paths
+
+    def _query_failed_imports(
+        self,
+    ) -> tuple[
+        ImporterFailedImportsUpdateStatus | None,
+        ImporterFailedImportsCreateStatus | None,
+        ImporterFailedImportsDeleteStatus | None,
+    ]:
+        """Determine what to do with failed imports."""
+        status = ImporterFailedImportsQueryStatus(0)
+        update_status = create_status = delete_status = None
+        try:
+            self.status_controller.start(status)
+            # Calculate creates and updates
+            fis = self.metadata.pop(FIS, {})
+            existing_failed_import_paths = set(
+                FailedImport.objects.filter(library=self.library).values_list(
+                    "path", flat=True
+                )
+            )
+            status.total = len(fis) + len(existing_failed_import_paths)
+            self.status_controller.update(status)
+            self.metadata[UPDATE_FIS] = {}
+            self.metadata[CREATE_FIS] = {}
+            for path, exc in fis.items():
+                if path in existing_failed_import_paths:
+                    self.metadata[UPDATE_FIS][path] = exc
+                else:
+                    self.metadata[CREATE_FIS][path] = exc
+                status.increment_complete()
+            self.status_controller.update(status)
+            if num_update := len(self.metadata[UPDATE_FIS]):
+                update_status = ImporterFailedImportsUpdateStatus(0, num_update)
+                self.status_controller.update(update_status)
+            if num_create := len(self.metadata[CREATE_FIS]):
+                create_status = ImporterFailedImportsCreateStatus(0, num_create)
+                self.status_controller.update(create_status)
+
+            if DELETE_FI_PATHS not in self.metadata:
+                self.metadata[DELETE_FI_PATHS] = set()
+            self.metadata[DELETE_FI_PATHS] |= self._query_failed_import_deletes(
+                existing_failed_import_paths, fis.keys()
+            )
+            status.increment_complete(len(existing_failed_import_paths))
+            if num_delete := len(self.metadata[DELETE_FI_PATHS]):
+                delete_status = ImporterFailedImportsDeleteStatus(0, num_delete)
+                self.status_controller.update(delete_status)
+        finally:
+            self.status_controller.finish(status, notify=True)
+        return update_status, create_status, delete_status

codex/librarian/scribe/importer/init.py

@@ -38,7 +38,7 @@ from codex.librarian.scribe.importer.statii.query import (
 )
 from codex.librarian.scribe.importer.statii.read import (
     ImporterAggregateStatus,
-    ImporterReadStatus,
+    ImporterReadComicsStatus,
 )
 from codex.librarian.scribe.importer.statii.search import (
     ImporterFTSCreateStatus,
@@ -214,7 +214,7 @@ class InitImporter(WorkerStatusMixin):
         """Initialize librarian statuses for modified or created ops."""
         total_paths = len(self.task.files_modified) + len(self.task.files_created)
         status_list += [
-            ImporterReadStatus(0, total_paths, subtitle=path),
+            ImporterReadComicsStatus(0, total_paths, subtitle=path),
             ImporterAggregateStatus(0, total_paths, subtitle=path),
             ImporterQueryMissingTagsStatus(subtitle=path),
             ImporterQueryComicUpdatesStatus(subtitle=path),

codex/librarian/scribe/importer/link/covers.py

@@ -6,7 +6,7 @@ from codex.librarian.scribe.importer.const import (
     CLASS_CUSTOM_COVER_GROUP_MAP,
     LINK_COVER_PKS,
 )
-from codex.librarian.scribe.importer.failed_imports import FailedImportsImporter
+from codex.librarian.scribe.importer.failed.failed import FailedImportsImporter
 from codex.librarian.scribe.importer.statii.link import ImporterLinkCoversStatus
 from codex.models import CustomCover, Folder
 

codex/librarian/scribe/importer/read/aggregate_path.py

@@ -18,8 +18,10 @@ from codex.librarian.scribe.importer.const import (
     QUERY_MODELS,
 )
 from codex.librarian.scribe.importer.read.folders import AggregatePathMetadataImporter
+from codex.librarian.scribe.importer.statii.failed import (
+    ImporterFailedImportsQueryStatus,
+)
 from codex.librarian.scribe.importer.statii.read import ImporterAggregateStatus
-from codex.librarian.scribe.importer.status import ImporterFailedImportsStatus
 
 _UNUSED_COMICBOX_FIELDS = (
     "alternate_images",
@@ -102,7 +104,7 @@ class AggregateMetadataImporter(AggregatePathMetadataImporter):
         fis = self.metadata[FIS].keys()
 
         # Set statii
-        fi_status = ImporterFailedImportsStatus(0, len(fis))
+        fi_status = ImporterFailedImportsQueryStatus(0, len(fis))
         self.status_controller.update(fi_status, notify=False)
         self.status_controller.finish(status)
         return status.complete

codex/librarian/scribe/importer/search/__init__.py

@@ -21,7 +21,7 @@ class SearchIndexImporter(SearchIndexPrepareImporter):
         indexer = SearchIndexer(
             self.log, self.librarian_queue, self.db_write_lock, event=self.abort_event
         )
-        return indexer.remove_stale_records()
+        return indexer.remove_stale_records(log_success=False)
 
     def full_text_search(self):
         """Sync the fts index with the imported database."""

codex/librarian/scribe/importer/search/update.py

@@ -22,6 +22,7 @@ from codex.librarian.scribe.importer.search.sync_m2m import (
 )
 from codex.librarian.scribe.importer.statii.search import (
     ImporterFTSCreateStatus,
+    ImporterFTSStatus,
     ImporterFTSUpdateStatus,
 )
 from codex.librarian.status import Status
@@ -128,7 +129,7 @@ class SearchIndexCreateUpdateImporter(SearchIndexSyncManyToManyImporter):
         *,
         create: bool,
     ):
-        if self.abort_event.is_set():
+        if not obj_list or self.abort_event.is_set():
             return
         verb = "create" if create else "update"
         verbing = (verb[:-1] + "ing").capitalize()
@@ -144,10 +145,40 @@ class SearchIndexCreateUpdateImporter(SearchIndexSyncManyToManyImporter):
 
     def _update_search_index_operate_get_status(
         self, total_entries: int, *, create: bool
-    ):
+    ) -> ImporterFTSStatus:
         status_class = ImporterFTSCreateStatus if create else ImporterFTSUpdateStatus
         return status_class(total=total_entries)
 
+    def _update_search_index_operate_create(
+        self, obj_list: list, status: ImporterFTSStatus
+    ):
+        entries = self.metadata.pop(FTS_CREATE, {})
+        pks = tuple(entries.keys())
+        for pk in pks:
+            if self.abort_event.is_set():
+                return ()
+
+            entry = entries.pop(pk)
+            self._create_comicfts_entry(pk, entry, obj_list, status)
+        return pks
+
+    def _update_search_index_operate_update(
+        self, obj_list: list, status: ImporterFTSStatus
+    ):
+        if pks := tuple(self.metadata.get(FTS_UPDATE, {}).keys()):
+            comicftss = ComicFTS.objects.filter(comic_id__in=pks)
+            for comicfts in comicftss:
+                if self.abort_event.is_set():
+                    return ()
+                self._update_comicfts_entry(comicfts, obj_list, status)
+            if self.metadata[FTS_UPDATE]:
+                # If updates not popped, turn them into creates.
+                if FTS_CREATE not in self.metadata:
+                    self.metadata[FTS_CREATE] = {}
+                self.metadata[FTS_CREATE].update(self.metadata[FTS_UPDATE])
+        self.metadata.pop(FTS_UPDATE)
+        return pks
+
     def _update_search_index_operate(self, *, create: bool) -> tuple[int, ...]:
         key = FTS_CREATE if create else FTS_UPDATE
         total_entries = len(self.metadata.get(key, {}))
@@ -161,27 +192,22 @@ class SearchIndexCreateUpdateImporter(SearchIndexSyncManyToManyImporter):
                 self.log.debug(f"No search entries to {verb}.")
                 return updated_pks
             self.status_controller.start(status)
+            verbing = "creating" if create else "updating"
+            self.log.debug(
+                f"Preparing {total_entries} comics for search index {verbing}..."
+            )
 
             obj_list = []
             if create:
-                entries = self.metadata.pop(FTS_CREATE, {})
-                pks = tuple(entries.keys())
-                for pk in pks:
-                    if self.abort_event.is_set():
-                        return updated_pks
-                    entry = entries.pop(pk)
-                    self._create_comicfts_entry(pk, entry, obj_list, status)
-                updated_pks = pks
+                updated_pks = self._update_search_index_operate_create(obj_list, status)
             else:
-                comic_ids = tuple(self.metadata[FTS_UPDATE].keys())
-                comicftss = ComicFTS.objects.filter(comic_id__in=comic_ids)
-                for comicfts in comicftss:
-                    if self.abort_event.is_set():
-                        return tuple(updated_pks)
-                    self._update_comicfts_entry(comicfts, obj_list, status)
-                self.metadata.pop(FTS_UPDATE)
-
-            self.log.debug(f"Preparing {total_entries} comics for search indexing...")
+                updated_pks = self._update_search_index_operate_update(obj_list, status)
+            self.log.debug(
+                f"Prepared {len(obj_list)} comics for search index {verbing}..."
+            )
+            if self.abort_event.is_set():
+                return updated_pks
+
             self._update_search_index_create_or_update(
                 obj_list,
                 status,

codex/librarian/scribe/importer/statii/__init__.py

@@ -2,6 +2,7 @@
 
 from codex.librarian.scribe.importer.statii.create import CREATE_STATII
 from codex.librarian.scribe.importer.statii.delete import REMOVE_STATII
+from codex.librarian.scribe.importer.statii.failed import FAILED_IMPORTS_STATII
 from codex.librarian.scribe.importer.statii.link import LINK_STATII
 from codex.librarian.scribe.importer.statii.moved import MOVED_STATII
 from codex.librarian.scribe.importer.statii.query import QUERY_STATII
@@ -16,4 +17,5 @@ IMPORTER_STATII = (
     *QUERY_STATII,
     *READ_STATII,
     *IMPORTER_SEARCH_INDEX_STATII,
+    *FAILED_IMPORTS_STATII,
 )

codex/librarian/scribe/importer/statii/failed.py

@@ -0,0 +1,50 @@
+"""Importer Failed Imports Sattii."""
+
+from abc import ABC
+
+from codex.librarian.scribe.importer.status import ImporterStatus
+
+
+class ImporterFailedImportStatus(ImporterStatus, ABC):
+    """Importer Failed Imports Statii."""
+
+    ITEM_NAME = "failed imports"
+
+
+class ImporterFailedImportsQueryStatus(ImporterFailedImportStatus, ABC):
+    """Importer Failed Imports Query Statii."""
+
+    CODE = "IFQ"
+    VERB = "Query"
+    _verbed = "Queried"
+
+
+class ImporterFailedImportsUpdateStatus(ImporterFailedImportStatus, ABC):
+    """Importer Failed Imports Update Statii."""
+
+    CODE = "IFU"
+    VERB = "Update"
+
+
+class ImporterFailedImportsCreateStatus(ImporterFailedImportStatus, ABC):
+    """Importer Failed Imports Create Statii."""
+
+    CODE = "IFC"
+    VERB = "Mark Failed"
+    _verbed = "Marked Failed"
+
+
+class ImporterFailedImportsDeleteStatus(ImporterFailedImportStatus, ABC):
+    """Importer Failed Imports Create Statii."""
+
+    CODE = "IFD"
+    VERB = "Clean up"
+    _verbed = "Cleaned up"
+
+
+FAILED_IMPORTS_STATII = (
+    ImporterFailedImportsQueryStatus,
+    ImporterFailedImportsUpdateStatus,
+    ImporterFailedImportsCreateStatus,
+    ImporterFailedImportsDeleteStatus,
+)

codex/librarian/scribe/importer/status.py

@@ -7,15 +7,3 @@ from codex.librarian.scribe.status import ScribeStatus
 
 class ImporterStatus(ScribeStatus, ABC):
     """Importer Status."""
-
-
-class ImporterFailedImportsStatus(ImporterStatus):
-    """Importer Failed Imports Status."""
-
-    CODE = "IFI"
-    VERB = "Mark"
-    _verbed = "Marked"
-    ITEM_NAME = "failed imports"
-
-
-FAILED_IMPORTS_STATII = (ImporterFailedImportsStatus,)

codex/librarian/scribe/janitor/janitor.py

@@ -13,6 +13,7 @@ from codex.librarian.scribe.janitor.status import (
     JanitorCodexLatestVersionStatus,
     JanitorDBBackupStatus,
     JanitorDBFKIntegrityStatus,
+    JanitorDBFTSIntegrityStatus,
     JanitorDBIntegrityStatus,
     JanitorDBOptimizeStatus,
 )
@@ -36,28 +37,34 @@ from codex.librarian.scribe.janitor.update import JanitorCodexUpdate
 from codex.librarian.scribe.search.status import (
     SearchIndexCleanStatus,
     SearchIndexOptimizeStatus,
+    SearchIndexSyncCreateStatus,
+    SearchIndexSyncUpdateStatus,
 )
 from codex.librarian.scribe.search.tasks import (
     SearchIndexOptimizeTask,
+    SearchIndexSyncTask,
 )
 from codex.models import Timestamp
 
 _JANITOR_STATII = (
     JanitorCodexLatestVersionStatus,
+    JanitorAdoptOrphanFoldersStatus,
+    ImporterMoveFoldersStatus,
     JanitorDBFKIntegrityStatus,
     JanitorDBIntegrityStatus,
-    JanitorCleanupCoversStatus,
+    JanitorDBFTSIntegrityStatus,
     JanitorCleanupTagsStatus,
+    JanitorCleanupCoversStatus,
     JanitorCleanupSessionsStatus,
     JanitorCleanupBookmarksStatus,
+    SearchIndexCleanStatus,
+    SearchIndexSyncUpdateStatus,
+    SearchIndexSyncCreateStatus,
+    SearchIndexOptimizeStatus,
     JanitorDBOptimizeStatus,
     JanitorDBBackupStatus,
     FindOrphanCoversStatus,
     RemoveCoversStatus,
-    JanitorAdoptOrphanFoldersStatus,
-    ImporterMoveFoldersStatus,
-    SearchIndexCleanStatus,
-    SearchIndexOptimizeStatus,
 )
 
 
@@ -78,6 +85,7 @@ class Janitor(JanitorCodexUpdate):
                 JanitorCleanCoversTask(),
                 JanitorCleanupSessionsTask(),
                 JanitorCleanupBookmarksTask(),
+                SearchIndexSyncTask(),
                 SearchIndexOptimizeTask(),
                 JanitorVacuumTask(),
                 JanitorBackupTask(),