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

codex/librarian/covers/create.py

@@ -58,7 +58,7 @@ class CoverCreateMixin(CoverPathMixin):
             return f.read()
 
     @classmethod
-    def create_cover_from_path(cls, pk, cover_path, log, librarian_queue, custom=False):  # noqa: PLR0913
+    def create_cover_from_path(cls, pk, cover_path, log, librarian_queue, custom=False):
         """Create cover for path.
 
         Called from views/cover.

codex/librarian/cron/crond.py

@@ -30,21 +30,23 @@ class CronThread(NamedThread):
         self._task_times = ()
         super().__init__(*args, name=self.__class__.__name__, daemon=True, **kwargs)
 
-    def _update_task_times(self):
+    def _create_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
 
-        task_tuple = tuple(sorted(task_times.items()))
-
-        # There's always at least the janitor job
-        self._next_time = task_tuple[0][0]
-        self._task_times = task_tuple
+        self._task_times = 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
+
+        next_time = self._task_times[0][0]
         now = django_timezone.now()
-        delta = self._next_time - now
+        delta = next_time - now
+        self.log.debug(f"Next scheduled job at {next_time} in {delta}.")
         return max(0, int(delta.total_seconds()))
 
     def _run_expired_jobs(self):
@@ -53,6 +55,7 @@ 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):
@@ -62,13 +65,13 @@ class CronThread(NamedThread):
             with self._cond:
                 while not self._stop_event.is_set():
                     self._run_expired_jobs()
-                    self._update_task_times()
+                    self._create_task_times()
+                    sleep(2)  # try to fix double jobs
                     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)  # fixes any time rounding problems
+                    sleep(2)  # fix 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,5 +1,7 @@
 """Bulk import and move comics and folders."""
 
+from pathlib import Path
+
 from django.utils import timezone
 
 from codex.librarian.importer.importer import ComicImporter
@@ -46,6 +48,15 @@ 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 = (
@@ -53,17 +64,20 @@ class ComicImporterThread(QueuedThread):
             .exclude(path=library.path)
             .values_list("path", flat=True)
         )
-        if not orphan_folder_paths:
+        # 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:
             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,
@@ -89,15 +103,6 @@ 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
@@ -105,9 +110,9 @@ class ComicImporterThread(QueuedThread):
             self._import(task)
         elif isinstance(task, LazyImportComicsTask):
             self._lazy_import_metadata(task)
-        elif isinstance(task, AdoptOrphanFoldersTask):
-            self._adopt_orphan_folders()
         elif isinstance(task, UpdateGroupsTask):
             self._update_groups(task)
+        elif isinstance(task, AdoptOrphanFoldersTask):
+            self._adopt_orphan_folders()
         else:
             self.log.warning(f"Bad task sent to library updater {task}")

codex/librarian/importer/moved.py

@@ -2,6 +2,7 @@
 
 from pathlib import Path
 
+from bidict import bidict
 from django.db.models.functions import Now
 
 from codex.librarian.importer.aggregate import AggregateMetadataImporter
@@ -23,20 +24,42 @@ from codex.status import Status
 class MovedImporter(AggregateMetadataImporter):
     """Methods for moving comics and folders."""
 
-    def _bulk_comics_moved(self):
-        """Move comcis."""
-        num_files_moved = len(self.task.files_moved)
-        if not num_files_moved:
+    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
-        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)
+        # 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:
+            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)
 
-        # Update Comics
+    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."""
         comics = Comic.objects.filter(
             library=self.library, path__in=self.task.files_moved.keys()
         ).only("pk", "path", PARENT_FOLDER, FOLDERS_FIELD)
@@ -44,29 +67,29 @@ class MovedImporter(AggregateMetadataImporter):
         folder_m2m_links = {}
         updated_comics = []
         for comic in comics.iterator():
-            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._prepare_moved_comic(comic, folder_m2m_links, updated_comics)
         self.task.files_moved = {}
+        self.log.debug(f"Prepared {len(updated_comics)} for move...")
+        return updated_comics, folder_m2m_links
 
-        Comic.objects.bulk_update(updated_comics, MOVED_BULK_COMIC_UPDATE_FIELDS)
+    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)
 
-        # Update m2m field
+        # 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)
         if folder_m2m_links:
             self.bulk_fix_comic_m2m_field(FOLDERS_FIELD, folder_m2m_links, status)
-        count = len(comics)
+
+        count = len(updated_comics)
         if count:
             self.log.info(f"Moved {count} comics.")
 
@@ -140,60 +163,32 @@ class MovedImporter(AggregateMetadataImporter):
         self.changed += count
         self.status_controller.finish(status)
 
-    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)
+    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")
         )
-        self.bulk_folders_create(create_folder_paths, status)
 
-        # 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")
+        # TODO what if a folder with that path already exists in the db?
 
+        new_paths = set()
         update_folders = []
         for folder in folders_to_move.iterator():
-            new_path = self.task.dirs_moved[folder.path]
+            new_path = dirs_moved[folder.path]
+            new_paths.add(new_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.get(parent_path_str)
+            folder.parent_folder = dest_parent_folders_map.get(parent_path_str)
             folder.presave()
             folder.updated_at = Now()
             update_folders.append(folder)
-        self.task.dirs_moved = {}
+
+        # 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))
 
@@ -202,6 +197,112 @@ 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):
@@ -233,6 +334,8 @@ 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

@@ -159,7 +159,7 @@ class QueryForeignKeysImporter(QueryCustomCoversImporter):
 
         filter_args[key] = group_name
 
-    def _get_create_group_set(  # noqa: PLR0913
+    def _get_create_group_set(
         self, groups, group_cls, create_group_set, update_group_set, status
     ):
         """Create the create group set."""
@@ -544,19 +544,22 @@ 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)
-        status.add_complete(
-            self._query_missing_simple_models(
-                names,
-                fk_data,
-                status,
-            )
+        count = 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)
@@ -575,15 +578,18 @@ 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
-        count = len(create_folder_paths)
-        if count:
+        if count := len(create_folder_paths):
             self.log.info(f"Prepared {count} new Folders.")
-        return count
 
     def _get_create_fks_totals(self):
         fkc = self.metadata[FK_CREATE]
@@ -634,7 +640,7 @@ class QueryForeignKeysImporter(QueryCustomCoversImporter):
                     status,
                 )
 
-            self.query_missing_folder_paths(
+            self._add_missing_folder_paths(
                 self.metadata[FKS].pop(COMIC_PATHS, ()), status
             )
 

codex/librarian/janitor/janitor.py

@@ -8,6 +8,7 @@ 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,
@@ -16,6 +17,7 @@ from codex.librarian.janitor.tasks import (
     JanitorCleanFKsTask,
     JanitorCleanupSessionsTask,
     JanitorClearStatusTask,
+    JanitorLatestVersionTask,
     JanitorNightlyTask,
     JanitorRestartTask,
     JanitorShutdownTask,
@@ -47,10 +49,13 @@ _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, UpdateMixin, VacuumMixin, UpdateFailedImportsMixin):
+class Janitor(
+    CleanupMixin, LatestVersionMixin, UpdateMixin, UpdateFailedImportsMixin, VacuumMixin
+):
     """Janitor inline task runner."""
 
     def __init__(self, log_queue, librarian_queue):
@@ -65,14 +70,15 @@ class Janitor(CleanupMixin, UpdateMixin, VacuumMixin, UpdateFailedImportsMixin):
             ).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),
@@ -91,8 +97,10 @@ class Janitor(CleanupMixin, UpdateMixin, VacuumMixin, UpdateFailedImportsMixin):
                     self.vacuum_db()
                 case JanitorBackupTask():
                     self.backup_db()
+                case JanitorLatestVersionTask():
+                    self.update_latest_version(task.force)
                 case JanitorUpdateTask():
-                    self.update_codex()
+                    self.update_codex(task.force)
                 case JanitorRestartTask():
                     self.restart_codex()
                 case JanitorShutdownTask():

codex/librarian/janitor/latest_version.py

@@ -0,0 +1,54 @@
+"""Fetch the current codex version."""
+
+import json
+from datetime import timedelta
+
+import requests
+from django.utils import timezone
+
+from codex.librarian.janitor.status import JanitorStatusTypes
+from codex.models import Timestamp
+from codex.status import Status
+from codex.version import PACKAGE_NAME
+from codex.worker_base import WorkerBaseMixin
+
+_PYPI_URL_TEMPLATE = "https://pypi.python.org/pypi/%s/json"
+_REPO_URL = _PYPI_URL_TEMPLATE % PACKAGE_NAME
+_CACHE_EXPIRY = timedelta(days=1) - timedelta(minutes=1)
+_REPO_TIMEOUT = 5
+
+
+class LatestVersionMixin(WorkerBaseMixin):
+    """Methods for fetching the latest version."""
+
+    @staticmethod
+    def _fetch_latest_version():
+        """Fetch Latest Remotely."""
+        response = requests.get(_REPO_URL, timeout=_REPO_TIMEOUT)
+        return json.loads(response.text)["info"]["version"]
+
+    def update_latest_version(self, force=False):
+        """Get the latest version from a remote repo using a cache."""
+        status = Status(JanitorStatusTypes.CODEX_LATEST_VERSION)
+        try:
+            self.status_controller.start(status)
+            ts = Timestamp.objects.get(
+                key=Timestamp.TimestampChoices.CODEX_VERSION.value
+            )
+            do_fetch = (
+                force
+                or not ts.version
+                or (timezone.now() - ts.updated_at > _CACHE_EXPIRY)
+            )
+            if do_fetch:
+                latest_version = self._fetch_latest_version()
+                if not latest_version:
+                    reason = "Bad latest version fetched."
+                    raise ValueError(reason)
+                ts.version = latest_version
+                ts.save()
+                self.log.info(f"Saved new latest codex version {latest_version}.")
+            else:
+                self.log.debug("Not fetching new latest version, not expired.")
+        finally:
+            self.status_controller.finish(status)

codex/librarian/janitor/status.py

@@ -7,6 +7,7 @@ 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,6 +8,20 @@ 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."""
@@ -23,13 +37,6 @@ class JanitorShutdownTask(JanitorTask):
     """for shutdown."""
 
 
-@dataclass
-class JanitorUpdateTask(JanitorTask):
-    """Task for updater."""
-
-    force: bool
-
-
 @dataclass
 class JanitorVacuumTask(JanitorTask):
     """Vacuum the database."""