codex 1.6.9a0__py3-none-any.whl → 1.6.10__py3-none-any.whl

codex/librarian/cron/crond.py

@@ -30,23 +30,21 @@ class CronThread(NamedThread):
         self._task_times = ()
         super().__init__(*args, name=self.__class__.__name__, daemon=True, **kwargs)
 
-    def _create_task_times(self):
+    def _update_task_times(self):
         task_times = {}
         for task_class, func in _TASK_TIME_FUNCTION_MAP.items():
             if dttm := func(self.log):
                 task_times[dttm] = task_class
 
-        self._task_times = tuple(sorted(task_times.items()))
+        task_tuple = tuple(sorted(task_times.items()))
 
-    def _get_timeout(self):
-        if not self._task_times or not self._task_times[0]:
-            self.log.warning("No scheduled jobs found. Not normal! Waiting a minute.")
-            return 60
+        # There's always at least the janitor job
+        self._next_time = task_tuple[0][0]
+        self._task_times = task_tuple
 
-        next_time = self._task_times[0][0]
+    def _get_timeout(self):
         now = django_timezone.now()
-        delta = next_time - now
-        self.log.debug(f"Next scheduled job at {next_time} in {delta}.")
+        delta = self._next_time - now
         return max(0, int(delta.total_seconds()))
 
     def _run_expired_jobs(self):
@@ -55,7 +53,6 @@ class CronThread(NamedThread):
             if dttm < now:
                 self.librarian_queue.put(task_class())
             else:
-                # Times are always ordered so stop checking at the first future job.
                 break
 
     def run(self):
@@ -65,13 +62,13 @@ class CronThread(NamedThread):
             with self._cond:
                 while not self._stop_event.is_set():
                     self._run_expired_jobs()
-                    self._create_task_times()
-                    sleep(2)  # try to fix double jobs
+                    self._update_task_times()
                     timeout = self._get_timeout()
+                    self.log.debug(f"Next scheduled job at {self._next_time}.")
                     self._cond.wait(timeout=timeout)
                     if self._stop_event.is_set():
                         break
-                    sleep(2)  # fix time rounding problems
+                    sleep(2)  # fixes any time rounding problems
         except Exception:
             self.log.exception(f"In {self.__class__.__name__}")
         self.log.debug(f"Stopped {self.__class__.__name__}.")

codex/librarian/importer/importerd.py

@@ -1,7 +1,5 @@
 """Bulk import and move comics and folders."""
 
-from pathlib import Path
-
 from django.utils import timezone
 
 from codex.librarian.importer.importer import ComicImporter
@@ -48,15 +46,6 @@ class ComicImporterThread(QueuedThread):
             )
             self._import(task)
 
-    def _update_groups(self, task):
-        pks = Library.objects.filter(covers_only=False).values_list("pk", flat=True)
-        start_time = task.start_time if task.start_time else timezone.now()
-        for pk in pks:
-            task = ImportDBDiffTask(library_id=pk)
-            importer = self._create_importer(task)
-            importer.update_all_groups({}, start_time)
-        self.librarian_queue.put(LIBRARY_CHANGED_TASK)
-
     def _adopt_orphan_folders_for_library(self, library):
         """Adopt orphan folders for one library."""
         orphan_folder_paths = (
@@ -64,20 +53,17 @@ class ComicImporterThread(QueuedThread):
             .exclude(path=library.path)
             .values_list("path", flat=True)
         )
-        # Move in place
-        # Exclude deleted folders
-        folders_moved = {
-            path: path for path in orphan_folder_paths if Path(path).is_dir()
-        }
-
-        if folders_moved:
-            self.log.debug(
-                f"{len(folders_moved)} orphan folders found in {library.path}"
-            )
-        else:
+        if not orphan_folder_paths:
             self.log.debug(f"No orphan folders in {library.path}")
             return False
 
+        self.log.debug(
+            f"{len(orphan_folder_paths)} orphan folders found in {library.path}"
+        )
+
+        # Move in place
+        folders_moved = {path: path for path in orphan_folder_paths}
+
         # An abridged import task.
         task = ImportDBDiffTask(
             library_id=library.pk,
@@ -103,6 +89,15 @@ class ComicImporterThread(QueuedThread):
 
         self.status_controller.finish_many((moved_status, status))
 
+    def _update_groups(self, task):
+        pks = Library.objects.filter(covers_only=False).values_list("pk", flat=True)
+        start_time = task.start_time if task.start_time else timezone.now()
+        for pk in pks:
+            task = ImportDBDiffTask(library_id=pk)
+            importer = self._create_importer(task)
+            importer.update_all_groups({}, start_time)
+        self.librarian_queue.put(LIBRARY_CHANGED_TASK)
+
     def process_item(self, item):
         """Run the updater."""
         task = item
@@ -110,9 +105,9 @@ class ComicImporterThread(QueuedThread):
             self._import(task)
         elif isinstance(task, LazyImportComicsTask):
             self._lazy_import_metadata(task)
-        elif isinstance(task, UpdateGroupsTask):
-            self._update_groups(task)
         elif isinstance(task, AdoptOrphanFoldersTask):
             self._adopt_orphan_folders()
+        elif isinstance(task, UpdateGroupsTask):
+            self._update_groups(task)
         else:
             self.log.warning(f"Bad task sent to library updater {task}")

codex/librarian/importer/moved.py

@@ -2,7 +2,6 @@
 
 from pathlib import Path
 
-from bidict import bidict
 from django.db.models.functions import Now
 
 from codex.librarian.importer.aggregate import AggregateMetadataImporter
@@ -24,42 +23,20 @@ from codex.status import Status
 class MovedImporter(AggregateMetadataImporter):
     """Methods for moving comics and folders."""
 
-    def _bulk_comics_moved_ensure_folders(self):
-        """Ensure folders we're moving to exist."""
-        dest_comic_paths = self.task.files_moved.values()
-        if not dest_comic_paths:
-            return
-        # Not sending statues to the controller for now.
-        status = Status(ImportStatusTypes.QUERY_MISSING_FKS)
-        create_folder_paths = self.query_missing_folder_paths(dest_comic_paths, status)
-        if not create_folder_paths:
+    def _bulk_comics_moved(self):
+        """Move comcis."""
+        num_files_moved = len(self.task.files_moved)
+        if not num_files_moved:
             return
-        status = Status(ImportStatusTypes.CREATE_FKS, 0, len(create_folder_paths))
-        self.log.debug(
-            "Creating {len(create_folder_paths)} folders for {len(dest_comic_paths)} moved comics."
-        )
-        self.bulk_folders_create(create_folder_paths, status)
+        status = Status(ImportStatusTypes.FILES_MOVED, 0, num_files_moved)
+        self.status_controller.start(status)
+
+        # Prepare FKs
+        create_folder_paths = set()
+        self.query_missing_folder_paths(create_folder_paths, status)
+        self.bulk_folders_create(frozenset(create_folder_paths), status)
 
-    def _prepare_moved_comic(self, comic, folder_m2m_links, updated_comics):
-        """Prepare one comic for bulk update."""
-        try:
-            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.updated_at = Now()
-            comic.presave()
-            folder_m2m_links[comic.pk] = Folder.objects.filter(
-                path__in=new_path.parents
-            ).values_list("pk", flat=True)
-            updated_comics.append(comic)
-        except Exception:
-            self.log.exception(f"moving {comic.path}")
-
-    def _bulk_comics_move_prepare(self):
-        """Prepare Update Comics."""
+        # Update Comics
         comics = Comic.objects.filter(
             library=self.library, path__in=self.task.files_moved.keys()
         ).only("pk", "path", PARENT_FOLDER, FOLDERS_FIELD)
@@ -67,29 +44,29 @@ class MovedImporter(AggregateMetadataImporter):
         folder_m2m_links = {}
         updated_comics = []
         for comic in comics.iterator():
-            self._prepare_moved_comic(comic, folder_m2m_links, updated_comics)
+            try:
+                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.updated_at = Now()
+                comic.presave()
+                folder_m2m_links[comic.pk] = Folder.objects.filter(
+                    path__in=new_path.parents
+                ).values_list("pk", flat=True)
+                updated_comics.append(comic)
+            except Exception:
+                self.log.exception(f"moving {comic.path}")
         self.task.files_moved = {}
-        self.log.debug(f"Prepared {len(updated_comics)} for move...")
-        return updated_comics, folder_m2m_links
-
-    def _bulk_comics_moved(self):
-        """Move comcis."""
-        num_files_moved = len(self.task.files_moved)
-        if not num_files_moved:
-            return
-        status = Status(ImportStatusTypes.FILES_MOVED, 0, num_files_moved)
-        self.status_controller.start(status)
 
-        # Prepare
-        self._bulk_comics_moved_ensure_folders()
-        updated_comics, folder_m2m_links = self._bulk_comics_move_prepare()
-
-        # Update comics
         Comic.objects.bulk_update(updated_comics, MOVED_BULK_COMIC_UPDATE_FIELDS)
+
+        # Update m2m field
         if folder_m2m_links:
             self.bulk_fix_comic_m2m_field(FOLDERS_FIELD, folder_m2m_links, status)
-
-        count = len(updated_comics)
+        count = len(comics)
         if count:
             self.log.info(f"Moved {count} comics.")
 
@@ -163,32 +140,60 @@ class MovedImporter(AggregateMetadataImporter):
         self.changed += count
         self.status_controller.finish(status)
 
-    def _bulk_move_folders(
-        self, src_folder_paths, dest_parent_folders_map, dirs_moved: bidict, status
-    ):
-        """Bulk move folders."""
-        folders_to_move = (
-            Folder.objects.filter(library=self.library, path__in=src_folder_paths)
-            .only(*MOVED_BULK_FOLDER_UPDATE_FIELDS)
-            .order_by("path")
+    def _get_parent_folders(self, dest_folder_paths, status):
+        """Get destination parent folders."""
+        # Determine parent folder paths.
+        dest_parent_folder_paths = set()
+        for dest_folder_path in dest_folder_paths:
+            dest_parent_path = str(Path(dest_folder_path).parent)
+            if dest_parent_path not in dest_folder_paths:
+                dest_parent_folder_paths.add(dest_parent_path)
+
+        # Create only intermediate subfolders.
+        existing_folder_paths = Folder.objects.filter(
+            library=self.library, path__in=dest_parent_folder_paths
+        ).values_list("path", flat=True)
+        create_folder_paths = frozenset(
+            dest_parent_folder_paths - frozenset(existing_folder_paths)
         )
+        self.bulk_folders_create(create_folder_paths, status)
 
-        # TODO what if a folder with that path already exists in the db?
+        # get parent folders path to model obj dict
+        dest_parent_folders_objs = Folder.objects.filter(
+            path__in=dest_parent_folder_paths
+        ).only("path", "pk")
+        dest_parent_folders = {}
+        for folder in dest_parent_folders_objs.iterator():
+            dest_parent_folders[folder.path] = folder
+        return dest_parent_folders
+
+    def bulk_folders_moved(self):
+        """Move folders in the database instead of recreating them."""
+        num_dirs_moved = len(self.task.dirs_moved)
+        if not num_dirs_moved:
+            return
+        status = Status(ImportStatusTypes.DIRS_MOVED, None, num_dirs_moved)
+        self.status_controller.start(status)
+
+        dest_folder_paths = frozenset(self.task.dirs_moved.values())
+        dest_parent_folders = self._get_parent_folders(dest_folder_paths, status)
+
+        src_folder_paths = frozenset(self.task.dirs_moved.keys())
+        folders_to_move = Folder.objects.filter(
+            library=self.library, path__in=src_folder_paths
+        ).order_by("path")
 
-        new_paths = set()
         update_folders = []
         for folder in folders_to_move.iterator():
-            new_path = dirs_moved[folder.path]
-            new_paths.add(new_path)
+            new_path = self.task.dirs_moved[folder.path]
             folder.name = Path(new_path).name
             folder.path = new_path
             parent_path_str = str(Path(new_path).parent)
-            folder.parent_folder = dest_parent_folders_map.get(parent_path_str)
+            folder.parent_folder = dest_parent_folders.get(parent_path_str)
             folder.presave()
             folder.updated_at = Now()
             update_folders.append(folder)
-
-        # delete_folders = Folder.objects.filter(library=self.library, path__in=new_paths)
+        self.task.dirs_moved = {}
 
         update_folders = sorted(update_folders, key=lambda x: len(Path(x.path).parts))
 
@@ -197,112 +202,6 @@ class MovedImporter(AggregateMetadataImporter):
         if count:
             self.log.info(f"Moved {count} folders.")
         self.changed += count
-        status.add_complete(count)
-        self.status_controller.update(status, notify=False)
-
-    def _bulk_move_folders_under_existing_parents(
-        self, dest_parent_folder_paths_map, dirs_moved, status
-    ):
-        """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
-            ).only("path")
-
-            # Create a list of folders than can be moved under existing folders.
-            dest_parent_folders_map = {}
-            src_folder_paths = []
-            for extant_parent_folder in extant_parent_folders:
-                dest_parent_folders_map[extant_parent_folder.path] = (
-                    extant_parent_folder
-                )
-                if dest_folder_paths := dest_parent_folder_paths_map.pop(
-                    extant_parent_folder.path
-                ):
-                    for dest_folder_path in dest_folder_paths:
-                        src_path = dirs_moved.inverse[dest_folder_path]
-                        src_folder_paths.append(src_path)
-
-            if not src_folder_paths:
-                return
-            src_folder_paths = sorted(src_folder_paths)
-            self.log.debug(f"Moving folders under existing parents: {src_folder_paths}")
-
-            self._bulk_move_folders(
-                src_folder_paths, dest_parent_folders_map, dirs_moved, status
-            )
-
-    def _get_move_create_folders_one_layer(self, dest_parent_folder_paths_map):
-        """Find the next layer of folder paths to create."""
-        create_folder_paths_one_layer = set()
-        library_parts_len = len(Path(self.library.path).parts)
-        for parent_path_str in sorted(dest_parent_folder_paths_map.keys()):
-            parts = Path(parent_path_str).parts
-            # Get one layer of folders from existing layers.
-            possible_create_folder_path = ""
-            for index in range(library_parts_len, len(parts) + 1):
-                layer_parts = parts[:index]
-                possible_create_folder_path = str(Path(*layer_parts))
-                if (
-                    possible_create_folder_path in create_folder_paths_one_layer
-                    or not Folder.objects.filter(
-                        library=self.library, path=possible_create_folder_path
-                    ).exists()
-                ):
-                    break
-            else:
-                possible_create_folder_path = ""
-            if possible_create_folder_path:
-                create_folder_paths_one_layer.add(possible_create_folder_path)
-
-        return frozenset(create_folder_paths_one_layer)
-
-    def _bulk_move_folders_and_create_parents(self, status):
-        """Find folders that can be moved without creating parents."""
-        dirs_moved = bidict(self.task.dirs_moved)
-
-        dest_parent_folder_paths_map = {}
-        for dest_path in sorted(set(dirs_moved.values())):
-            parent = str(Path(dest_path).parent)
-            if parent not in dest_parent_folder_paths_map:
-                dest_parent_folder_paths_map[parent] = set()
-            dest_parent_folder_paths_map[parent].add(dest_path)
-
-        create_status = Status(ImportStatusTypes.CREATE_FKS)
-        layer = 1
-        while True:
-            self._bulk_move_folders_under_existing_parents(
-                dest_parent_folder_paths_map, dirs_moved, status
-            )
-
-            # All folders movable without creation have moved.
-            if not dest_parent_folder_paths_map:
-                break
-            self.log.debug(
-                f"Creating intermediate folder layer {layer} to move folders."
-            )
-            create_folder_paths_one_layer = self._get_move_create_folders_one_layer(
-                dest_parent_folder_paths_map
-            )
-
-            # Create one layer of folders
-            self.bulk_folders_create(create_folder_paths_one_layer, create_status)
-            layer += 1
-
-    def bulk_folders_moved(self):
-        """Move folders in the database instead of recreating them."""
-        num_dirs_moved = len(self.task.dirs_moved)
-        if not num_dirs_moved:
-            return
-        status = Status(ImportStatusTypes.DIRS_MOVED, None, num_dirs_moved)
-        self.status_controller.start(status)
-
-        self._bulk_move_folders_and_create_parents(status)
-        self.task.dirs_moved = {}
-
         self.status_controller.finish(status)
 
     def _bulk_folders_modified(self):
@@ -334,8 +233,6 @@ class MovedImporter(AggregateMetadataImporter):
 
     def move_and_modify_dirs(self):
         """Move files and dirs and modify dirs."""
-        # It would be nice to move folders instead of recreating them but it would require
-        # an inode map from the snapshots to do correctly.
         self.bulk_folders_moved()
         self._bulk_comics_moved()
         self._bulk_covers_moved()

codex/librarian/importer/query_fks.py

@@ -544,22 +544,19 @@ class QueryForeignKeysImporter(QueryCustomCoversImporter):
             base_cls = Comic
         fk_data = self.metadata[FK_CREATE][FKC_CREATE_FKS], base_cls, fk_field, "name"
         names = self.metadata[FKS].pop(fk_field)
-        count = self._query_missing_simple_models(
-            names,
-            fk_data,
-            status,
+        status.add_complete(
+            self._query_missing_simple_models(
+                names,
+                fk_data,
+                status,
+            )
         )
-        status.add_complete(count)
         self.status_controller.update(status, notify=False)
 
     ###########
     # FOLDERS #
     ###########
-    def query_missing_folder_paths(
-        self,
-        comic_paths,
-        status,
-    ):
+    def query_missing_folder_paths(self, comic_paths, status):
         """Find missing folder paths."""
         # Get the proposed folder_paths
         library_path = Path(self.library.path)
@@ -578,18 +575,15 @@ class QueryForeignKeysImporter(QueryCustomCoversImporter):
             status,
         )
         create_folder_paths = create_folder_paths_dict.get(Folder, set())
-        return frozenset(create_folder_paths)
-
-    def _add_missing_folder_paths(self, comic_paths, status):
-        create_folder_paths = self.query_missing_folder_paths(comic_paths, status)
-        """Add missing folder_paths to create fks."""
         if FK_CREATE not in self.metadata:
             self.metadata[FK_CREATE] = {}
         if FKC_FOLDER_PATHS not in self.metadata[FK_CREATE]:
             self.metadata[FK_CREATE][FKC_FOLDER_PATHS] = set()
         self.metadata[FK_CREATE][FKC_FOLDER_PATHS] |= create_folder_paths
-        if count := len(create_folder_paths):
+        count = len(create_folder_paths)
+        if count:
             self.log.info(f"Prepared {count} new Folders.")
+        return count
 
     def _get_create_fks_totals(self):
         fkc = self.metadata[FK_CREATE]
@@ -640,7 +634,7 @@ class QueryForeignKeysImporter(QueryCustomCoversImporter):
                     status,
                 )
 
-            self._add_missing_folder_paths(
+            self.query_missing_folder_paths(
                 self.metadata[FKS].pop(COMIC_PATHS, ()), status
             )
 

codex/librarian/janitor/janitor.py

@@ -8,7 +8,6 @@ from codex.librarian.importer.tasks import (
 )
 from codex.librarian.janitor.cleanup import TOTAL_NUM_FK_CLASSES, CleanupMixin
 from codex.librarian.janitor.failed_imports import UpdateFailedImportsMixin
-from codex.librarian.janitor.latest_version import LatestVersionMixin
 from codex.librarian.janitor.status import JanitorStatusTypes
 from codex.librarian.janitor.tasks import (
     ForceUpdateAllFailedImportsTask,
@@ -17,7 +16,6 @@ from codex.librarian.janitor.tasks import (
     JanitorCleanFKsTask,
     JanitorCleanupSessionsTask,
     JanitorClearStatusTask,
-    JanitorLatestVersionTask,
     JanitorNightlyTask,
     JanitorRestartTask,
     JanitorShutdownTask,
@@ -49,13 +47,10 @@ _JANITOR_STATII = (
     Status(SearchIndexStatusTypes.SEARCH_INDEX_UPDATE),
     Status(SearchIndexStatusTypes.SEARCH_INDEX_REMOVE),
     Status(SearchIndexStatusTypes.SEARCH_INDEX_MERGE),
-    Status(JanitorStatusTypes.CODEX_LATEST_VERSION),
 )
 
 
-class Janitor(
-    CleanupMixin, LatestVersionMixin, UpdateMixin, UpdateFailedImportsMixin, VacuumMixin
-):
+class Janitor(CleanupMixin, UpdateMixin, VacuumMixin, UpdateFailedImportsMixin):
     """Janitor inline task runner."""
 
     def __init__(self, log_queue, librarian_queue):
@@ -70,15 +65,14 @@ class Janitor(
             ).on
             self.status_controller.start_many(_JANITOR_STATII)
             tasks = (
-                JanitorLatestVersionTask(),
-                JanitorUpdateTask(force=False),
                 SearchIndexAbortTask(),
                 JanitorCleanFKsTask(),
                 JanitorCleanCoversTask(),
                 JanitorCleanupSessionsTask(),
-                AdoptOrphanFoldersTask(),
                 JanitorVacuumTask(),
                 JanitorBackupTask(),
+                JanitorUpdateTask(force=False),
+                AdoptOrphanFoldersTask(),
                 CoverRemoveOrphansTask(),
                 SearchIndexUpdateTask(False),
                 SearchIndexMergeTask(optimize),
@@ -97,10 +91,8 @@ class Janitor(
                     self.vacuum_db()
                 case JanitorBackupTask():
                     self.backup_db()
-                case JanitorLatestVersionTask():
-                    self.update_latest_version(task.force)
                 case JanitorUpdateTask():
-                    self.update_codex(task.force)
+                    self.update_codex()
                 case JanitorRestartTask():
                     self.restart_codex()
                 case JanitorShutdownTask():

codex/librarian/janitor/status.py

@@ -7,7 +7,6 @@ class JanitorStatusTypes(Choices):
     """Janitor Status Types."""
 
     CLEANUP_FK = "JTD"
-    CODEX_LATEST_VERSION = "JLV"
     CODEX_UPDATE = "JCU"
     CODEX_RESTART = "JCR"
     CODEX_STOP = "JCS"

codex/librarian/janitor/tasks.py

@@ -8,20 +8,6 @@ class JanitorTask:
     """Tasks for the janitor."""
 
 
-@dataclass
-class JanitorLatestVersionTask(JanitorTask):
-    """Get the latest version."""
-
-    force: bool = False
-
-
-@dataclass
-class JanitorUpdateTask(JanitorTask):
-    """Task for updater."""
-
-    force: bool = False
-
-
 @dataclass
 class JanitorBackupTask(JanitorTask):
     """Backup the database."""
@@ -37,6 +23,13 @@ class JanitorShutdownTask(JanitorTask):
     """for shutdown."""
 
 
+@dataclass
+class JanitorUpdateTask(JanitorTask):
+    """Task for updater."""
+
+    force: bool
+
+
 @dataclass
 class JanitorVacuumTask(JanitorTask):
     """Vacuum the database."""

codex/librarian/janitor/update.py

@@ -5,36 +5,17 @@ import signal
 import subprocess
 import sys
 
-from versio.version import Version
-
 from codex.librarian.janitor.status import JanitorStatusTypes
 from codex.librarian.tasks import LibrarianShutdownTask
 from codex.models import AdminFlag
-from codex.models.admin import Timestamp
 from codex.status import Status
-from codex.version import VERSION, get_version
+from codex.version import PACKAGE_NAME, VERSION, get_version, is_outdated
 from codex.worker_base import WorkerBaseMixin
 
 
 class UpdateMixin(WorkerBaseMixin):
     """Update codex methods for janitor."""
 
-    def _is_outdated(self):
-        """Is codex outdated."""
-        result = False
-        ts = Timestamp.objects.get(key=Timestamp.TimestampChoices.CODEX_VERSION.value)
-        latest_version = ts.version
-        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
-            pre_blurb = "latest version is a prerelease. But installed version is not."
-        else:
-            result = versio_latest_version > installed_versio_version
-            pre_blurb = ""
-        self.log.info(f"{latest_version=} > {VERSION=} = {result}{pre_blurb}")
-        return result
-
     def update_codex(self, force=False):
         """Update the package and restart everything if the version changed."""
         status = Status(JanitorStatusTypes.CODEX_UPDATE)
@@ -46,7 +27,7 @@ class UpdateMixin(WorkerBaseMixin):
                 eau = AdminFlag.objects.only("on").get(
                     key=AdminFlag.FlagChoices.AUTO_UPDATE.value
                 )
-                if not eau.on or not self._is_outdated():
+                if not eau.on or not is_outdated(PACKAGE_NAME):
                     self.log.info("Codex is up to date.")
                     return
 

codex/librarian/janitor/vacuum.py

@@ -21,7 +21,8 @@ class VacuumMixin(WorkerBaseMixin):
             self.status_controller.start(status)
             old_size = DB_PATH.stat().st_size
             with connection.cursor() as cursor:
-                cursor.execute("PRAGMA optimize")
+                cursor.execute("PRAGMA analysis_limit=400;")
+                cursor.execute("PRAGMA optimize;")
                 cursor.execute("VACUUM")
                 cursor.execute("PRAGMA wal_checkpoint(TRUNCATE)")
             new_size = DB_PATH.stat().st_size