v2.2.7

Dockerfile

@@ -13,7 +13,7 @@
 ###############################################################################
 
 # ---- Stage 1: builder (build tools + Node for compilation) -----------------
-FROM nikolaik/python-nodejs:python3.14-nodejs24 AS builder-base
+FROM nikolaik/python-nodejs:python3.14-nodejs26 AS builder-base
 # nodejs25 blocked on bug https://github.com/nodejs/node/issues/60303
 
 COPY debian.sources /etc/apt/sources.list.d/

NEWS.md

@@ -6,6 +6,14 @@ width: 128px;
 border-radius: 128px;
 " />
 
+## v2.2.7
+
+- Fixes
+    - A comic moved or renamed onto a path that already belongs to another
+      comic, like a duplicate landing in a dupes folder, no longer crashes the
+      scan and no longer crashes every scan after it. The stray move is skipped
+      and the leftover record is cleaned up by a later scan.
+
 ## v2.2.6
 
 - Features

bin/release-tag.sh

@@ -0,0 +1,11 @@
+#!/usr/bin/env bash
+# Merge main into develop and tag a release
+set -euo pipefail
+TAG=$1
+git checkout main
+git pull
+git tag v"$TAG"
+git push --tags
+git checkout develop
+git merge main --no-edit
+git push

codex/librarian/scribe/importer/moved/comics.py

@@ -1,5 +1,6 @@
 """Bulk import and move comics."""
 
+from collections.abc import Mapping
 from pathlib import Path
 
 from django.db.models.functions import Now
@@ -15,12 +16,78 @@
 from codex.librarian.scribe.importer.statii.create import ImporterCreateTagsStatus
 from codex.librarian.scribe.importer.statii.moved import ImporterMoveComicsStatus
 from codex.librarian.scribe.importer.statii.query import ImporterQueryMissingTagsStatus
-from codex.models import Comic, Folder
+from codex.models import Comic, CustomCover, Folder
 
 
 class MovedComicsImporter(ReadMetadataImporter):
     """Methods for moving comics and folders."""
 
+    def _remove_file_move_collisions(
+        self,
+        model: type[Comic] | type[CustomCover],
+        moves: Mapping[str, str],
+        item_name: str,
+    ) -> dict[str, str]:
+        """
+        Remove moves whose destination path is already claimed.
+
+        The poller and the watcher both infer moves from inode matches
+        without checking that the destination is free in the database.
+        A destination that already belongs to another row would violate
+        the ``(library, path)`` unique constraint inside the upcoming
+        ``bulk_update``, and that exception aborted the entire import,
+        leaving the delete phase unreachable so the same task crashed
+        again on every subsequent scan.
+
+        Two claims are possible. An existing row may sit at the
+        destination already (a duplicate file landing on a tracked
+        path, or an overwrite-rename), or two sources in this batch may
+        resolve to the same destination, which ``files_moved`` can
+        express because it is a plain dict rather than the bidict
+        folder moves use. Drop both, keeping the lowest sorted source
+        for a duplicated destination so the choice is deterministic.
+
+        Skipping converges rather than stranding anything. The
+        destination row's stat is refreshed by the modified reimport or
+        by the poller's stale stat pass, so the next scan sees two rows
+        sharing an inode, suppresses the bogus move as ambiguous, and
+        the stale source falls through to the delete phase. Libraries
+        that only run the watcher wait for their next poll instead. A
+        source and destination that swap paths drop both moves and
+        reconcile as content changes in place, which a single
+        ``bulk_update`` could not express under SQLite anyway.
+
+        This is normal reconciliation, not a fault. Log at INFO with a
+        count and at DEBUG with the paths, matching the folder guard.
+        """
+        if not moves:
+            return {}
+        occupied_paths = frozenset(
+            model.objects.filter(
+                library=self.library, path__in=frozenset(moves.values())
+            ).values_list(PATH_FIELD_NAME, flat=True)
+        )
+        kept_moves: dict[str, str] = {}
+        claimed_paths: set[str] = set()
+        skipped_paths: list[str] = []
+        for src_path in sorted(moves):
+            dest_path = moves[src_path]
+            if dest_path in occupied_paths or dest_path in claimed_paths:
+                skipped_paths.append(src_path)
+            else:
+                kept_moves[src_path] = dest_path
+                claimed_paths.add(dest_path)
+        if skipped_paths:
+            count = len(skipped_paths)
+            plural = "s" if count != 1 else ""
+            msg = (
+                f"Resolved {count} phantom {item_name} move{plural} by skipping "
+                "the rename and leaving the destinations in place."
+            )
+            self.log.info(msg)
+            self.log.debug(f"Skipped {item_name} move sources: {skipped_paths}")
+        return kept_moves
+
     def _bulk_comics_moved_ensure_folders(self) -> None:
         """Ensure folders we're moving to exist."""
         dest_comic_paths = self.task.files_moved.values()
@@ -125,14 +192,21 @@ def _bulk_comics_move_prepare(self) -> tuple[list, dict, dict]:
         return updated_comics, folder_m2m_links, del_rows_map
 
     def bulk_comics_moved(self) -> int:
-        """Move comcis."""
+        """Move comics."""
+        count = 0
         num_files_moved = len(self.task.files_moved)
         status = ImporterMoveComicsStatus(0, num_files_moved)
         try:
             if not num_files_moved:
-                return 0
+                return count
             self.status_controller.start(status)
 
+            # Drop moves onto claimed paths before creating any folders
+            # for destinations that will not be used.
+            self.task.files_moved = self._remove_file_move_collisions(
+                Comic, self.task.files_moved, "comic"
+            )
+
             # Prepare
             self._bulk_comics_moved_ensure_folders()
             updated_comics, folder_m2m_links, del_rows_map = (
@@ -148,6 +222,12 @@ def bulk_comics_moved(self) -> int:
                 self.link_comic_m2m_field(FOLDERS_FIELD_NAME, folder_m2m_links, status)
 
             count = len(updated_comics)
+        except Exception:
+            # Broad by intent. A failed move phase must degrade to a
+            # skipped phase that the next scan reconciles, never abort
+            # the import, which left the delete phase unreachable and
+            # the same task crashing on every scan.
+            self.log.exception(f"Moving {num_files_moved} comics")
         finally:
             self.status_controller.finish(status)
         return count

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

@@ -62,13 +62,18 @@ def _bulk_covers_moved_unlink(self, unlink_pks) -> None:
 
     def bulk_covers_moved(self, status=None) -> int:
         """Move covers."""
+        count = 0
         num_covers_moved = len(self.task.covers_moved)
         status = ImporterMoveCoversStatus(None, num_covers_moved)
         try:
             if not num_covers_moved:
-                return 0
+                return count
             self.status_controller.start(status)
 
+            self.task.covers_moved = self._remove_file_move_collisions(
+                CustomCover, self.task.covers_moved, "custom cover"
+            )
+
             moved_covers, unlink_pks = self._bulk_covers_moved_prepare(status)
             if LINK_COVER_PKS not in self.metadata:
                 self.metadata[LINK_COVER_PKS] = set()
@@ -83,6 +88,9 @@ def bulk_covers_moved(self, status=None) -> int:
             count = len(moved_covers)
             level = "INFO" if count else "DEBUG"
             self.log.log(level, f"Moved {count} custom covers.")
+        except Exception:
+            # Broad by intent, as in bulk_comics_moved.
+            self.log.exception(f"Moving {num_covers_moved} custom covers")
         finally:
             self.status_controller.finish(status)
         return count

codex/librarian/scribe/importer/moved/folders.py

@@ -225,6 +225,11 @@ def bulk_folders_moved(self, *, mark_in_progress=False) -> int:
 
             count += self._bulk_move_folders_and_create_parents(status)
             self.task.dirs_moved = {}
+        except Exception:
+            # Broad by intent, as in bulk_comics_moved. Converting
+            # dirs_moved to a bidict raises when two sources share a
+            # destination, which the watcher can emit.
+            self.log.exception(f"Moving {num_dirs_moved} folders")
         finally:
             self.status_controller.finish(status)
             if mark_in_progress:

codex/views/admin/onlinetag.py

@@ -3,6 +3,8 @@
 import contextlib
 import uuid
 from dataclasses import fields
+from types import MappingProxyType
+from typing import Final
 
 from rest_framework.response import Response
 from rest_framework.status import HTTP_202_ACCEPTED, HTTP_409_CONFLICT
@@ -34,6 +36,16 @@
 from codex.views.admin.identifier_parse import parse_identifier_input
 from codex.views.admin.tagwrite import FilteredComicPksView
 
+# Boolean scan knobs the request may omit, mapped to the field on the stored
+# tagging defaults that supplies the fallback.
+_FLAG_DEFAULT_FIELDS: Final = MappingProxyType(
+    {
+        "delete_original": "delete_original",
+        "merge_all_sources": "merge_all_sources",
+        "rename": "rename_files",
+    }
+)
+
 
 def _configured_sources(defaults: ComicboxTaggingDefaults | None) -> frozenset[str]:
     """Which online sources actually have credentials configured."""
@@ -123,6 +135,16 @@ def _comic_pks_error(self, comic_pks: frozenset[int], *, pinned: bool) -> str:
             return "Tagging by id requires a single comic."
         return ""
 
+    @staticmethod
+    def _resolve_flags(data: dict, defaults: ComicboxTaggingDefaults | None) -> dict:
+        """Take each boolean knob from the request, falling back to the defaults."""
+        return {
+            key: bool(requested)
+            if (requested := data.get(key)) is not None
+            else bool(defaults and getattr(defaults, default_field))
+            for key, default_field in _FLAG_DEFAULT_FIELDS.items()
+        }
+
     def post(self, request):
         """Validate and enqueue a BulkOnlineTagTask."""
         serializer = OnlineTagStartSerializer(data=request.data)
@@ -146,35 +168,14 @@ def post(self, request):
             return Response({"detail": detail}, status=400)
 
         session_id = str(uuid.uuid4())
-
-        req_delete = data.get("delete_original")
-        if req_delete is not None:
-            delete_original = req_delete
-        else:
-            delete_original = bool(defaults and defaults.delete_original)
-
-        req_merge = data.get("merge_all_sources")
-        if req_merge is not None:
-            merge_all_sources = req_merge
-        else:
-            merge_all_sources = bool(defaults and defaults.merge_all_sources)
-
-        req_rename = data.get("rename")
-        if req_rename is not None:
-            rename = req_rename
-        else:
-            rename = bool(defaults and defaults.rename_files)
-
         task = BulkOnlineTagTask(
             comic_pks=comic_pks,
             session_id=session_id,
             sources=tuple(data["sources"]),
             mode=data["mode"],
             prompts_mode=data["prompts_mode"],
-            delete_original=delete_original,
-            merge_all_sources=merge_all_sources,
-            rename=rename,
             ids=ids,
+            **self._resolve_flags(data, defaults),
         )
         LIBRARIAN_QUEUE.put(task)
         return Response(

codex/views/browser/filters/search/field/filter.py

@@ -18,7 +18,7 @@ class BrowserFieldQueryFilter(ComicFieldFilterView):
     def _combine_q(q: Q, other_q: tuple[str, Any] | Q, op: str) -> Q:
         if isinstance(other_q, tuple):
             rel: str
-            rel, val = other_q  # ty: ignore[invalid-assignment]
+            rel, val = other_q
             if rel.endswith("__like") and val == "%":
                 # Remove likes that would match everything
                 return q