Merge remote-tracking branch 'origin/main' into feat/332-image-categories-pr3

The getCategories default was never used (images.mjs always passes the
toolbar's categories) and left images-selection.mjs function coverage at 97.05
(floor 98).

.github/workflows/viewerjs-check.yml

@@ -27,15 +27,6 @@ concurrency:
 # coverage shards 7m34s/6m04s/5m22s (tests 6m38s/4m53s/4m04s), merge 54s, firefox 7m57s/5m21s (tests
 # 7m08s/4m34s), webkit 8m16s/5m03s (tests 7m26s/3m58s); a cache miss adds up to 5m to npm ci, which
 # the 20-minute limits absorb.
-# Hangs (#425): a job killed at its limit keeps no log and skips its upload steps, so each browser
-# test step has its own timeout-minutes (18) below the job's 20. At the step limit, SIGTERM makes
-# tools/vendor/running-tests-reporter.mjs print the tests still running and hand over to Playwright's
-# interrupt, which writes the blob report; the always() uploads then run.
-# Measured on main (runs 40725289094, 40719375442, 40700439399): setup before the test step <= 52s,
-# uploads <= 35s; test steps up to 14m42s (webkit shard 1/2) and 13m05s for coverage (shard 1/3:
-# 12m53s, node units and the viewer suite before 11.8m of workflows), so coverage is the tight one
-# in its 18 minutes. This holds only when the npm cache hits: a cold cache adds up to 5m to npm ci,
-# and then the job limit can still end the job before the step limit does.
 jobs:
   frontend-coverage:
     name: frontend coverage (shard ${{ matrix.shard }}/3)
@@ -88,7 +79,6 @@ jobs:
       - if: matrix.shard == 3
         run: npm run --prefix tools/vendor test
       - name: Page workflows with coverage, shard ${{ matrix.shard }}/3
-        timeout-minutes: 18
         run: npm run --prefix tools/vendor test:coverage:shard -- ${{ matrix.shard }}/3
       - name: Upload raw coverage
         uses: actions/upload-artifact@v7
@@ -97,7 +87,6 @@ jobs:
           path: coverage/js/raw/
           if-no-files-found: error
           retention-days: 3
-      # Traces and the blob report (test-results/blob/) of a failed, timed-out or cancelled step.
       - name: Upload Chromium and touch traces
         if: always()
         uses: actions/upload-artifact@v7
@@ -222,9 +211,7 @@ jobs:
           key: npm-${{ runner.os }}-playwright-v1.64.1-${{ hashFiles('tools/vendor/package-lock.json') }}
       - run: npm ci --prefix tools/vendor --ignore-scripts
       - name: Page workflows in ${{ matrix.browser }}, shard ${{ matrix.shard }}/2
-        timeout-minutes: 18
         run: npm run --prefix tools/vendor test:workflows -- --project ${{ matrix.browser }} --shard ${{ matrix.shard }}/2
-      # Traces and the blob report (test-results/blob/) of a failed, timed-out or cancelled step.
       - name: Upload browser traces
         if: always()
         uses: actions/upload-artifact@v7

TESTING.md

@@ -262,31 +262,6 @@ watchdog dump, is a failure like any other: read the dump, find the blocking
 call, fix it. Never raise a limit or rerun to get green; a limit changes only
 with new measurements written next to it.
 
-Browser jobs (#425): GitHub keeps no log of a job killed at its limit and skips
-its upload steps, so the test step in each browser job in `viewerjs-check.yml`
-has its own `timeout-minutes` (18, below the job's 20). At the step limit
-GitHub sends SIGTERM, which would end Playwright without any report; under `CI`
-`tools/vendor/running-tests-reporter.mjs` catches the first one, prints
-`Still running when the run ended (SIGTERM): N` and one line per unfinished
-test (path relative to the suite's `rootDir`), then sends Playwright its own
-SIGINT, so the workers stop, the run ends interrupted and the blob report is
-written to `tools/vendor/test-results/blob/`. In the coverage job npm signals
-only `frontend-coverage.mjs`, which forwards SIGTERM and SIGINT to the child it
-is running (started in its own process group, so a group-wide signal still
-arrives once). Delivery is proven locally in the pinned image for a SIGTERM to
-the whole process group (`timeout -s TERM`). A SIGTERM to npm alone
-(`timeout --foreground`) reaches nothing: npm forwards it to the `sh -c` that
-runs the script, and that shell exits without passing it on. Delivery in CI,
-where the step runs through `docker exec`, is not yet observed; the next real
-step timeout will show it. That directory and the traces
-upload with `if: always()`; `npx playwright merge-reports` opens the blob.
-Each test keeps the 30 s default and there is no `globalTimeout`. Two limits
-of this: it assumes the npm cache hits (a cold cache adds up to 5 minutes to
-`npm ci`, and the job limit can then still win), and coverage shard 1 (12m53s
-measured) is the tight one in its 18-minute step. Local runs keep the `list`
-reporter only; reproduce with `CI=1 timeout -s TERM 40 npm run --prefix
-tools/vendor test:workflows -- --project=firefox`.
-
 ### After a push
 
 Follow the run for the commit you pushed, never an older one:

database/duplicate_copies.py

@@ -9,8 +9,6 @@ IMMEDIATE`` transaction, so no row ever names a deleted file:
   already links the kept copy: then its saved-pair links join that record
   and it is deleted;
 - its favorite;
-- its collection memberships (#331), joined onto the kept copy's as their
-  union under the same keys a favorite moves by;
 - its image tags (``media_image_tags`` of its byte record), joined onto the
   kept copy's byte record as their union, in order;
 - its own image category (#332), copied to the kept copy when that copy has
@@ -56,15 +54,6 @@ INSERT_FAVORITE_SQL = "INSERT OR IGNORE INTO image_favorites VALUES (?, ?, ?)"
 DELETE_FAVORITE_SQL = (
     "DELETE FROM image_favorites WHERE root_key = ? AND relative_path = ?"
 )
-COPY_MEMBERSHIPS_SQL = (
-    "INSERT OR IGNORE INTO image_collection_items "
-    "(collection_id, root_key, relative_path, added_at) "
-    "SELECT collection_id, ?, ?, added_at FROM image_collection_items "
-    "WHERE root_key = ? AND relative_path = ?"
-)
-DELETE_MEMBERSHIPS_SQL = (
-    "DELETE FROM image_collection_items WHERE root_key = ? AND relative_path = ?"
-)
 COPY_BYTE_SQL = (
     f"SELECT b.id FROM {FILES_TABLE} f JOIN {BYTES_TABLE} b "  # nosec B608
     "ON b.file_id=f.id WHERE f.locator=? AND b.sha256=?"
@@ -88,8 +77,6 @@ FILE_LINK_SQL = (
     DELETE_LINK_SQL,
     FAVORITE_SQL,
     DELETE_FAVORITE_SQL,
-    COPY_MEMBERSHIPS_SQL,
-    DELETE_MEMBERSHIPS_SQL,
     COPY_BYTE_SQL,
     COPY_TAG_COUNT_SQL,
     PENDING_COUNT_SQL,
@@ -153,17 +140,14 @@ class DuplicateCopyOperations:
         by), ``targets`` (``{removed spelling: kept spelling}``, the spelling
         a moved record takes; else ``kept_path``), ``favorites`` (``(root key,
         removed key, kept root key, kept key)`` per listed root holding the
-        file; they move its favorite and its collection memberships),
-        ``removed_locator``, ``kept_locator``, ``sha256`` and the kept copy's
-        ``kept_size`` and ``kept_mtime_ns``; ``categories``: ``(removed file
-        key, kept file key)`` pairs of the image categories (#332). Returns
-        ``{moved, merged, favorites, tags, review, collections, categories}``
-        (``collections``: the memberships inserted on the kept copy;
-        ``categories``: the image categories copied to the kept copy).
+        file), ``removed_locator``,
+        ``kept_locator``, ``sha256`` and the kept copy's ``kept_size`` and
+        ``kept_mtime_ns``; ``categories``: ``(removed file key, kept file
+        key)`` pairs of the image categories (#332). Returns ``{moved,
+        merged, favorites, tags, review, categories}`` (``categories``: the
+        image categories copied to the kept copy).
         """
-        counts = dict.fromkeys(
-            ("moved", "merged", "favorites", "tags", "review", "collections"), 0
-        )
+        counts = dict.fromkeys(("moved", "merged", "favorites", "tags", "review"), 0)
         kept_keys = [normalize_image_path(path) for path in move["kept"]]
         with self._pair_transaction() as conn:
             for spelled in dict.fromkeys(move["removed"]):
@@ -196,7 +180,6 @@ class DuplicateCopyOperations:
                     counts["moved"] += 1
             for favorite in move.get("favorites", ()):
                 counts["favorites"] += _move_favorite(conn, *favorite)
-                counts["collections"] += _move_memberships(conn, *favorite)
             counts["tags"] = self._move_copy_tags(conn, move)
             counts["categories"] = sum(
                 copy_image_category(conn, removed, kept)
@@ -241,12 +224,3 @@ def _move_favorite(conn, root_key, removed_key, kept_root, kept_key):
     conn.execute(INSERT_FAVORITE_SQL, (kept_root, kept_key, row[0]))
     conn.execute(DELETE_FAVORITE_SQL, (root_key, removed_key))
     return 1
-
-
-def _move_memberships(conn, root_key, removed_key, kept_root, kept_key):
-    """Copy a removed copy's memberships to the kept copy; the rows inserted."""
-    inserted = conn.execute(
-        COPY_MEMBERSHIPS_SQL, (kept_root, kept_key, root_key, removed_key)
-    ).rowcount
-    conn.execute(DELETE_MEMBERSHIPS_SQL, (root_key, removed_key))
-    return inserted

database/image_collections.py

@@ -1,490 +0,0 @@
-"""Collections (#331): named, hand-picked groups of image files.
-
-A member names its file exactly as a favorite does (``image_favorites.py``):
-the source folder's real, case-normalized path (``root_key``) and the path
-below it (``relative_path``), both server-side only. A member whose file is
-moved, renamed or deleted outside PromptManager is kept and simply not listed;
-nothing follows a file to a new place.
-
-Names are trimmed with each run of whitespace collapsed to one space, 1 to 100
-characters without control characters; ``name_key`` (NFC of the case-folded
-NFC name) is UNIQUE, so names are unique ignoring case and Unicode form.
-
-The two tables install like ``image_favorites`` and ``saved_views``: optional
-in old backups, required once a database is current, created empty with no
-backfill. Startup checks only the structure, so a value saved under older
-rules never stops the library from opening; restore checks the values too,
-but never recomputes ``name_key`` (case tables differ between Python
-versions).
-"""
-
-import re
-import sqlite3
-import unicodedata
-from typing import Optional
-
-from .image_favorites import MAX_KEY_LENGTH
-
-COLLECTIONS_TABLE = "image_collections"
-ITEMS_TABLE = "image_collection_items"
-FILE_INDEX = "idx_image_collection_items_file"
-TABLES = (COLLECTIONS_TABLE, ITEMS_TABLE)
-MAX_NAME_LENGTH = 100
-_TIMESTAMP_BYTES = 64
-# A name key's byte bound: case folding expands a character to at most
-# three, each at most 4 UTF-8 bytes.
-_MAX_KEY_BYTES = MAX_NAME_LENGTH * 3 * 4
-_WHITESPACE = re.compile(r"\s+")
-
-_TABLE_DDL = {
-    COLLECTIONS_TABLE: (
-        f"CREATE TABLE {COLLECTIONS_TABLE} (id INTEGER PRIMARY KEY AUTOINCREMENT, "
-        "name TEXT NOT NULL, name_key TEXT NOT NULL UNIQUE, "
-        "created_at TEXT NOT NULL)"
-    ),
-    ITEMS_TABLE: (
-        f"CREATE TABLE {ITEMS_TABLE} (collection_id INTEGER NOT NULL REFERENCES "
-        f"{COLLECTIONS_TABLE}(id) ON DELETE CASCADE, root_key TEXT NOT NULL, "
-        "relative_path TEXT NOT NULL, added_at TEXT NOT NULL, "
-        "PRIMARY KEY (collection_id, root_key, relative_path))"
-    ),
-}
-_INDEX_DDL = f"CREATE INDEX {FILE_INDEX} ON {ITEMS_TABLE}(root_key, relative_path)"
-# (name, declared type, not null, default, primary key position)
-_COLUMNS = {
-    COLLECTIONS_TABLE: (
-        ("id", "INTEGER", 0, None, 1),
-        ("name", "TEXT", 1, None, 0),
-        ("name_key", "TEXT", 1, None, 0),
-        ("created_at", "TEXT", 1, None, 0),
-    ),
-    ITEMS_TABLE: (
-        ("collection_id", "INTEGER", 1, None, 1),
-        ("root_key", "TEXT", 1, None, 2),
-        ("relative_path", "TEXT", 1, None, 3),
-        ("added_at", "TEXT", 1, None, 0),
-    ),
-}
-# (column, parent table, parent column, on delete)
-_FOREIGN_KEYS = {
-    COLLECTIONS_TABLE: set(),
-    ITEMS_TABLE: {("collection_id", COLLECTIONS_TABLE, "id", "CASCADE")},
-}
-
-
-class CollectionInvalid(ValueError):
-    """A name, id or target breaks the write rules (a 400)."""
-
-
-def _has_control(text: str) -> bool:
-    """Any Unicode control character (category Cc: C0, DEL and C1)."""
-    return any(unicodedata.category(char) == "Cc" for char in text)
-
-
-def normalize_collection_name(name: object) -> str:
-    """The stored spelling of *name*: trimmed, whitespace collapsed, checked.
-
-    Raises ``CollectionInvalid`` unless the result is 1 to 100 characters
-    without control characters.
-    """
-    if not isinstance(name, str):
-        raise CollectionInvalid("Name must be a string")
-    collapsed = _WHITESPACE.sub(" ", name).strip()
-    if not 1 <= len(collapsed) <= MAX_NAME_LENGTH:
-        raise CollectionInvalid(f"Name must be 1 to {MAX_NAME_LENGTH} characters")
-    if _has_control(collapsed):
-        raise CollectionInvalid("Name contains control characters")
-    return collapsed
-
-
-def collection_name_key(name: str) -> str:
-    """The uniqueness key of a name: NFC of the case-folded NFC spelling."""
-    return unicodedata.normalize("NFC", unicodedata.normalize("NFC", name).casefold())
-
-
-def _compact(sql: str) -> str:
-    return re.sub(r"\s+", "", sql).lower()
-
-
-def _expected_catalog() -> set:
-    objects = {("table", name, _compact(sql)) for name, sql in _TABLE_DDL.items()}
-    objects.add(("index", FILE_INDEX, _compact(_INDEX_DDL)))
-    objects |= {("index", f"sqlite_autoindex_{table}_1", "") for table in TABLES}
-    return objects
-
-
-def _catalog(conn: sqlite3.Connection) -> list:
-    # sqlite_sequence (AUTOINCREMENT) is shared with other tables and ignored.
-    return conn.execute(
-        "SELECT type,name,sql FROM sqlite_master "
-        "WHERE name IN (?,?,?) OR tbl_name IN (?,?)",
-        (*TABLES, FILE_INDEX, *TABLES),
-    ).fetchall()
-
-
-def _structure_error(conn: sqlite3.Connection) -> Optional[str]:
-    for table, expected in _COLUMNS.items():
-        columns = tuple(
-            (row[1], row[2].upper(), row[3], row[4], row[5])
-            for row in conn.execute(f"PRAGMA table_info({table})")
-        )
-        if columns != expected:
-            return f"Image collections table {table} has invalid columns"
-        foreign_keys = {
-            (row[3], row[2], row[4], row[6])
-            for row in conn.execute(f"PRAGMA foreign_key_list({table})")
-        }
-        if foreign_keys != _FOREIGN_KEYS[table]:
-            return f"Image collections table {table} has invalid foreign keys"
-    return None
-
-
-def _decoded_too_long(conn, sql: str, limit: int) -> bool:
-    """Whether a byte-bounded candidate row decodes to over *limit* characters."""
-    for row in conn.execute(sql):
-        for raw in row:
-            if len(bytes(raw).decode("utf-8", "replace")) > limit:
-                return True
-    return False
-
-
-def _value_error(conn: sqlite3.Connection) -> Optional[str]:
-    # Only this module's constants are interpolated into the SQL below. Bytes
-    # bound characters from above (UTF-8 is at most 4 bytes each); the few
-    # candidates over the character bound are measured decoded in Python.
-    if conn.execute(
-        f"SELECT 1 FROM {COLLECTIONS_TABLE} WHERE "  # nosec B608
-        "typeof(id) != 'integer' OR typeof(name) != 'text' "
-        "OR typeof(name_key) != 'text' OR typeof(created_at) != 'text' "
-        f"OR length(CAST(name AS BLOB)) > {MAX_NAME_LENGTH * 4} "
-        "OR length(CAST(name_key AS BLOB)) = 0 "
-        f"OR length(CAST(name_key AS BLOB)) > {_MAX_KEY_BYTES} "
-        f"OR length(CAST(created_at AS BLOB)) > {_TIMESTAMP_BYTES} LIMIT 1"
-    ).fetchone():
-        return "Image collections contains invalid values"
-    # The key is not recomputed: Unicode case tables differ between Python
-    # versions, and a key written by another version must stay restorable.
-    # Its UNIQUE constraint keeps names distinct; writes compute it.
-    for (name,) in conn.execute(f"SELECT name FROM {COLLECTIONS_TABLE}"):  # nosec B608
-        if (
-            not 1 <= len(name) <= MAX_NAME_LENGTH
-            or _has_control(name)
-            or name != name.strip()
-        ):
-            return "Image collections contains invalid names"
-    limit = MAX_KEY_LENGTH * 4
-    if conn.execute(
-        f"SELECT 1 FROM {ITEMS_TABLE} WHERE "  # nosec B608
-        "typeof(collection_id) != 'integer' OR typeof(root_key) != 'text' "
-        "OR typeof(relative_path) != 'text' OR typeof(added_at) != 'text' "
-        f"OR length(CAST(root_key AS BLOB)) > {limit} "
-        f"OR length(CAST(relative_path AS BLOB)) > {limit} "
-        f"OR length(CAST(added_at AS BLOB)) > {_TIMESTAMP_BYTES} LIMIT 1"
-    ).fetchone() or _decoded_too_long(
-        conn,
-        f"SELECT CAST(root_key AS BLOB), CAST(relative_path AS BLOB) "  # nosec B608
-        f"FROM {ITEMS_TABLE} WHERE length(CAST(root_key AS BLOB)) > {MAX_KEY_LENGTH} "
-        f"OR length(CAST(relative_path AS BLOB)) > {MAX_KEY_LENGTH}",
-        MAX_KEY_LENGTH,
-    ):
-        return "Image collections contains invalid members"
-    if conn.execute(f"PRAGMA foreign_key_check({ITEMS_TABLE})").fetchone():
-        return "Image collections contains members of a missing collection"
-    return None
-
-
-def image_collections_schema_error(
-    conn: sqlite3.Connection,
-    *,
-    allow_missing: bool = True,
-    check_values: bool = True,
-) -> Optional[str]:
-    """Reject partial or unsupported collections schemas and invalid rows.
-
-    Reads only: nothing is ever repaired. A database without either table is
-    acceptable for backups that predate them unless ``allow_missing`` is
-    false. ``check_values=False`` (live startup) checks the structure only.
-    """
-    objects = _catalog(conn)
-    if not objects:
-        return None if allow_missing else "Missing image collections schema"
-    present = {name for kind, name, _sql in objects if kind == "table"}
-    if present != set(TABLES):
-        return "Incomplete image collections schema"
-    actual = {(kind, name, _compact(sql or "")) for kind, name, sql in objects}
-    if actual != _expected_catalog():
-        return "Image collections has an invalid schema definition"
-    error = _structure_error(conn)
-    if error or not check_values:
-        return error
-    return _value_error(conn)
-
-
-def migrate_image_collections(conn: sqlite3.Connection) -> None:
-    """Install both tables atomically; validate before and after creating them."""
-    conn.execute("SAVEPOINT image_collections_schema")
-    try:
-        error = image_collections_schema_error(conn, check_values=False)
-        if error:
-            raise sqlite3.DatabaseError(error)
-        for sql in _TABLE_DDL.values():
-            conn.execute(sql.replace("CREATE TABLE", "CREATE TABLE IF NOT EXISTS", 1))
-        conn.execute(_INDEX_DDL.replace("INDEX", "INDEX IF NOT EXISTS", 1))
-        error = image_collections_schema_error(
-            conn, allow_missing=False, check_values=False
-        )
-        if error:
-            raise sqlite3.DatabaseError(error)
-        conn.execute("RELEASE image_collections_schema")
-    except BaseException:
-        conn.execute("ROLLBACK TO image_collections_schema")
-        conn.execute("RELEASE image_collections_schema")
-        raise
-
-
-class CollectionMissing(LookupError):
-    """No collection has the id (a 404 ``collection-not-found``)."""
-
-
-class CollectionNameTaken(ValueError):
-    """Another collection already has the name's key (a 409 ``name-taken``)."""
-
-    def __init__(self, collection_id: int):
-        super().__init__("Another collection has this name")
-        self.collection_id = collection_id
-
-
-class CollectionFilesMissing(LookupError):
-    """A new name with nothing to insert (a 404 ``files-not-found``)."""
-
-
-LIST_SQL = f"SELECT id, name FROM {COLLECTIONS_TABLE} ORDER BY name_key, id"
-GET_SQL = f"SELECT id, name FROM {COLLECTIONS_TABLE} WHERE id = ?"
-BY_KEY_SQL = f"SELECT id, name FROM {COLLECTIONS_TABLE} WHERE name_key = ?"
-MEMBERS_SQL = (
-    f"SELECT relative_path FROM {ITEMS_TABLE} "
-    "WHERE collection_id = ? AND root_key = ?"
-)
-ROOT_MEMBERS_SQL = (
-    f"SELECT collection_id, relative_path FROM {ITEMS_TABLE} WHERE root_key = ?"
-)
-COUNTS_SQL = (
-    f"SELECT c.id, (SELECT COUNT(*) FROM {ITEMS_TABLE} i "
-    f"WHERE i.collection_id = c.id) FROM {COLLECTIONS_TABLE} c"
-)
-FILE_SQL = (
-    f"SELECT collection_id FROM {ITEMS_TABLE} "
-    "WHERE root_key = ? AND relative_path = ? ORDER BY collection_id"
-)
-# Every read, for the EXPLAIN QUERY PLAN check: none scans the items table and
-# only the two whole-list reads (LIST_SQL, COUNTS_SQL) scan the collections.
-READ_SQL = (
-    LIST_SQL,
-    GET_SQL,
-    BY_KEY_SQL,
-    MEMBERS_SQL,
-    ROOT_MEMBERS_SQL,
-    COUNTS_SQL,
-    FILE_SQL,
-)
-_INSERT_ITEM_SQL = f"INSERT OR IGNORE INTO {ITEMS_TABLE} VALUES (?, ?, ?, ?)"
-_DELETE_ITEM_SQL = (
-    f"DELETE FROM {ITEMS_TABLE} "
-    "WHERE collection_id = ? AND root_key = ? AND relative_path = ?"
-)
-
-
-def _collection_id(value: object) -> int:
-    if type(value) is not int or not 1 <= value <= 999_999_999:
-        raise CollectionInvalid("Collection id must be a positive integer")
-    return value
-
-
-def _items(items: object) -> list:
-    """Distinct ``(root key, relative key)`` pairs, in order."""
-    if not isinstance(items, (list, tuple)):
-        raise CollectionInvalid("Items must be a list")
-    found = []
-    for item in items:
-        if (
-            not isinstance(item, (list, tuple))
-            or len(item) != 2
-            or not all(
-                isinstance(part, str) and 1 <= len(part) <= MAX_KEY_LENGTH
-                for part in item
-            )
-        ):
-            raise CollectionInvalid("Each item is a root key and a relative key")
-        found.append((item[0], item[1]))
-    return list(dict.fromkeys(found))
-
-
-def _row(row) -> dict:
-    return {"id": row[0], "name": row[1]}
-
-
-class ImageCollectionOperations:
-    """PromptDatabase mixin: collections and their members.
-
-    Each write runs in its own ``BEGIN IMMEDIATE`` transaction
-    (``_pair_transaction``), so two tabs creating one name are serialized.
-    """
-
-    def list_collections(self) -> list[dict]:
-        """Every collection ``{id, name}`` in name-key order, then id."""
-        rows = self.model.get_connection().execute(LIST_SQL)
-        return [_row(row) for row in rows]
-
-    def get_collection(self, collection_id: int) -> Optional[dict]:
-        """``{id, name}`` of one collection, or None."""
-        row = (
-            self.model.get_connection()
-            .execute(GET_SQL, (_collection_id(collection_id),))
-            .fetchone()
-        )
-        return _row(row) if row else None
-
-    def collection_exists(self, collection_id: int) -> bool:
-        return self.get_collection(collection_id) is not None
-
-    def collection_members(self, collection_id: int, root_key: str) -> set[str]:
-        """The relative keys stored for one collection under one source."""
-        rows = self.model.get_connection().execute(
-            MEMBERS_SQL, (_collection_id(collection_id), root_key)
-        )
-        return {path for (path,) in rows}
-
-    def root_collection_members(self, root_key: str) -> dict[int, set[str]]:
-        """``{collection id: relative keys}`` stored under one source."""
-        found: dict[int, set[str]] = {}
-        for collection_id, path in self.model.get_connection().execute(
-            ROOT_MEMBERS_SQL, (root_key,)
-        ):
-            found.setdefault(collection_id, set()).add(path)
-        return found
-
-    def collection_count_snapshot(self, root_keys: list) -> tuple[dict, dict]:
-        """``({root key: {id: relative keys}}, {id: stored rows})`` read in
-        one read transaction, so a write between the reads cannot skew them.
-        """
-        conn = self.model.get_connection()
-        if conn.in_transaction:
-            raise RuntimeError("Collection counts require their own transaction")
-        conn.execute("BEGIN")
-        try:
-            members = {}
-            for root_key in dict.fromkeys(root_keys):
-                found: dict[int, set[str]] = {}
-                for collection_id, path in conn.execute(ROOT_MEMBERS_SQL, (root_key,)):
-                    found.setdefault(collection_id, set()).add(path)
-                members[root_key] = found
-            stored = {cid: count for cid, count in conn.execute(COUNTS_SQL)}
-        finally:
-            conn.rollback()  # it only read
-        return members, stored
-
-    def collection_counts(self) -> dict[int, int]:
-        """``{collection id: stored rows}`` for every collection."""
-        rows = self.model.get_connection().execute(COUNTS_SQL)
-        return {collection_id: count for collection_id, count in rows}
-
-    def file_collections(self, root_key: str, relative_path: str) -> list[int]:
-        """Ids of the collections holding one file."""
-        rows = self.model.get_connection().execute(FILE_SQL, (root_key, relative_path))
-        return [collection_id for (collection_id,) in rows]
-
-    def add_to_collection(
-        self, *, items: object, collection_id: object = None, name: object = None
-    ) -> dict:
-        """Add files to an existing id or a name; create the name when needed.
-
-        A name whose key exists uses that collection; otherwise a collection
-        is created only when at least one item is inserted. Returns
-        ``{collection, created, added, already}``.
-        """
-        from .models import utc_now_iso  # models imports this module's schema
-
-        if (collection_id is None) == (name is None):
-            raise CollectionInvalid("Give either a collection id or a name")
-        pairs = _items(items)
-        if name is not None:
-            spelled = normalize_collection_name(name)
-        else:
-            collection_id = _collection_id(collection_id)
-        now = utc_now_iso()
-        with self._pair_transaction() as conn:
-            created = False
-            if name is not None:
-                row = conn.execute(
-                    BY_KEY_SQL, (collection_name_key(spelled),)
-                ).fetchone()
-                if row is None:
-                    if not pairs:
-                        raise CollectionFilesMissing("Nothing to add")
-                    cursor = conn.execute(
-                        f"INSERT INTO {COLLECTIONS_TABLE} "  # nosec B608
-                        "(name, name_key, created_at) VALUES (?, ?, ?)",
-                        (spelled, collection_name_key(spelled), now),
-                    )
-                    row, created = (cursor.lastrowid, spelled), True
-            else:
-                row = conn.execute(GET_SQL, (collection_id,)).fetchone()
-                if row is None:
-                    raise CollectionMissing("No such collection")
-            collection = _row(row)
-            added = sum(
-                conn.execute(
-                    _INSERT_ITEM_SQL, (collection["id"], root, path, now)
-                ).rowcount
-                for root, path in pairs
-            )
-        return {
-            "collection": collection,
-            "created": created,
-            "added": added,
-            "already": len(pairs) - added,
-        }
-
-    def remove_from_collection(self, collection_id: object, items: object) -> dict:
-        """Remove files from one collection; ``{collection, removed}``."""
-        collection_id = _collection_id(collection_id)
-        pairs = _items(items)
-        with self._pair_transaction() as conn:
-            row = conn.execute(GET_SQL, (collection_id,)).fetchone()
-            if row is None:
-                raise CollectionMissing("No such collection")
-            removed = sum(
-                conn.execute(_DELETE_ITEM_SQL, (collection_id, root, path)).rowcount
-                for root, path in pairs
-            )
-        return {"collection": _row(row), "removed": removed}
-
-    def rename_collection(self, collection_id: object, name: object) -> dict:
-        """The renamed ``{id, name}``; a case variant of its own name is fine."""
-        collection_id = _collection_id(collection_id)
-        spelled = normalize_collection_name(name)
-        key = collection_name_key(spelled)
-        with self._pair_transaction() as conn:
-            if conn.execute(GET_SQL, (collection_id,)).fetchone() is None:
-                raise CollectionMissing("No such collection")
-            taken = conn.execute(BY_KEY_SQL, (key,)).fetchone()
-            if taken is not None and taken[0] != collection_id:
-                raise CollectionNameTaken(taken[0])
-            conn.execute(
-                f"UPDATE {COLLECTIONS_TABLE} SET name = ?, name_key = ? "  # nosec B608
-                "WHERE id = ?",
-                (spelled, key, collection_id),
-            )
-        return {"id": collection_id, "name": spelled}
-
-    def delete_collection(self, collection_id: object) -> bool:
-        """Delete one collection and its members (never a file). True."""
-        collection_id = _collection_id(collection_id)
-        with self._pair_transaction() as conn:
-            cursor = conn.execute(
-                f"DELETE FROM {COLLECTIONS_TABLE} WHERE id = ?",  # nosec B608
-                (collection_id,),
-            )
-            if cursor.rowcount == 0:
-                raise CollectionMissing("No such collection")
-        return True

database/models.py

@@ -22,10 +22,6 @@ from .managed_connection import (
 from . import restore_stage
 from .library_schema import library_schema_error, migrate_library_state
 from .image_favorites import image_favorites_schema_error, migrate_image_favorites
-from .image_collections import (
-    image_collections_schema_error,
-    migrate_image_collections,
-)
 from .annotation_schema import annotation_schema_error, migrate_annotation_state
 from .autotag_schema import (
     autotag_schema_error,
@@ -342,7 +338,6 @@ class PromptModel:
         migrate_library_state(conn)
         migrate_image_favorites(conn)
         migrate_saved_views(conn)
-        migrate_image_collections(conn)
         # A review group without its annotation group is refused before the
         # annotation install could make it look valid (catalog only; the rows
         # are validated once, in migrate_review_state).
@@ -1164,8 +1159,8 @@ class PromptModel:
             path: File to inspect
             require_library_state: Also require the tables every current
                 database has (Library state, image favorites, image
-                categories, saved views, collections, image annotations and
-                the review queue), as a migrated
+                categories, saved views, image annotations and the review
+                queue), as a migrated
                 restore stage must; old backups may lack them.
             documents: Read every workflow document and refuse a damaged
                 one. A restore checks its upload without it and repairs
@@ -1239,11 +1234,6 @@ class PromptModel:
             )
             if views_error:
                 return False, views_error
-            collections_error = image_collections_schema_error(
-                conn, allow_missing=not require_library_state
-            )
-            if collections_error:
-                return False, collections_error
             annotation_error = annotation_schema_error(
                 conn, allow_missing=not require_library_state
             )

database/operations.py

@@ -18,7 +18,6 @@ from .models import PromptModel, normalize_image_path, utc_now_iso
 from .pairs import PairDependencyError, PairOperations  # noqa: F401 (re-exported)
 from .library import LibraryOperations, titled
 from .image_favorites import ImageFavoriteOperations
-from .image_collections import ImageCollectionOperations
 from .annotations import AnnotationOperations
 from .review import ReviewOperations
 from .review_decisions import ReviewDecisionOperations
@@ -454,7 +453,6 @@ class PromptDatabase(
     ExecutionOutputOperations,
     HistoryReadOperations,
     ImageFavoriteOperations,
-    ImageCollectionOperations,
     AnnotationOperations,
     ReviewOperations,
     ReviewDecisionOperations,

database/restore_stage.py

@@ -59,7 +59,6 @@ SUMMARY_KEYS = (
     "image_links",
     "runs",
     "saved_views",
-    "collections",
 )
 
 
@@ -145,8 +144,7 @@ def library_summary(conn: sqlite3.Connection) -> Dict[str, int]:
     ``positives`` are the Library's prompts (``library_counts``'s
     ``positive_prompts``); ``pairs`` the active saved pairs and
     ``archived_pairs`` the archived ones; ``image_links`` the indexed image
-    rows; ``runs`` the recorded executions; ``collections`` the image
-    collections (#331).
+    rows; ``runs`` the recorded executions.
     """
     from .library import _ELIGIBLE
 
@@ -171,7 +169,6 @@ def library_summary(conn: sqlite3.Connection) -> Dict[str, int]:
         "image_links": _count(conn, "generated_images"),
         "runs": _count(conn, "execution_runs"),
         "saved_views": _count(conn, "saved_views"),
-        "collections": _count(conn, "image_collections"),
     }
 
 
@@ -183,7 +180,6 @@ _FINGERPRINT_SQL = (
     ("prompt_pairs", "SELECT MAX(id), MAX(updated_at) FROM prompt_pairs"),
     ("execution_runs", "SELECT COUNT(*), MAX(rowid) FROM execution_runs"),
     ("saved_views", "SELECT MAX(rowid) FROM saved_views"),
-    ("image_collections", "SELECT MAX(rowid) FROM image_collections"),
 )
 
 
@@ -194,9 +190,9 @@ def live_fingerprint(conn: sqlite3.Connection):
     tables a restore replaces, or when a prompt, pair, run or saved view is
     the newest edited (counts plus the newest row and edit of each table);
     the apply refuses with ``plan-changed`` then. It does not see every
-    edit (a tag, favorite or collection membership change on an older row);
-    those are kept in the restore's safety backup. A read transaction the
-    caller already has is used and left open; one opened here is ended here.
+    edit (a tag or favorite change on an older row); those are kept in the
+    restore's safety backup. A read transaction the caller already has is
+    used and left open; one opened here is ended here.
     """
     import json
 

py/api/__init__.py

@@ -48,7 +48,6 @@ from .review import ReviewRoutesMixin
 from .review_recording import ReviewRecordingMixin
 from .review_events import ReviewEventsMixin
 from .saved_views import SavedViewRoutesMixin
-from .collections import CollectionRoutesMixin
 from .history import HistoryRoutesMixin
 from .images import ImageRoutesMixin
 from .gallery_listing import WALK_STOPPED, RootListing, WalkOutcome
@@ -316,7 +315,6 @@ class PromptManagerAPI(
     ReviewRecordingMixin,
     ReviewEventsMixin,
     SavedViewRoutesMixin,
-    CollectionRoutesMixin,
     HistoryRoutesMixin,
     PromptRoutesMixin,
     ImageRoutesMixin,
@@ -688,7 +686,6 @@ class PromptManagerAPI(
         self._register_review_routes(routes)
         self._register_review_event_routes(routes)
         self._register_saved_view_routes(routes)
-        self._register_collection_routes(routes)
         self._register_history_routes(routes)
         self._register_prompt_routes(routes)
         self._register_image_routes(routes)

py/api/annotation_suggest.py

@@ -86,23 +86,6 @@ def unavailable_message(model_name: str) -> str:
     return f"{model_name} is not downloaded. {UNAVAILABLE_HINT}"
 
 
-def model_refusal(status: dict, model_type: str, model_name: str):
-    """Why *model_type* cannot run, from ``get_models_status()``, else None.
-
-    Not downloaded first (``unavailable_message``), then a backend package
-    that cannot be imported (#424). Both are a 409 ``model-unavailable``.
-    """
-    entry = status.get(model_type) or {}
-    if not entry.get("downloaded"):
-        return unavailable_message(model_name)
-    missing = entry.get("missing_packages") or []
-    if missing:
-        from ..autotag import missing_packages_message
-
-        return missing_packages_message(model_type, [str(name) for name in missing])
-    return None
-
-
 def run_suggestions(service, capture_path: str, model_type: str, options: dict):
     """Blocking: load (or swap to) *model_type*, then suggest for the capture.
 

py/api/annotations.py

@@ -21,9 +21,9 @@ from aiohttp import web
 from .annotation_suggest import (
     SUGGEST_FIELDS,
     OptionError,
-    model_refusal,
     run_suggestions,
     suggestion_rows,
+    unavailable_message,
     validate_options,
 )
 from .autotag_routes import model_busy_response
@@ -595,7 +595,7 @@ class AnnotationRoutesMixin:
         it, including a legacy batch), never downloads (``model-unavailable``)
         and never writes.
         """
-        from ..autotag import MODELS, MissingBackendPackages, get_autotag_service
+        from ..autotag import MODELS, get_autotag_service
         from ..config import MAX_SUGGESTION_LIMIT, AutotagConfig
 
         data, error = await self._annotation_body(request, SUGGEST_FIELDS)
@@ -633,10 +633,9 @@ class AnnotationRoutesMixin:
                 return error
             service = get_autotag_service()
             status = await self._run_in_executor(service.get_models_status)
-            name = MODELS.get(model_type, {}).get("name", model_type)
-            refusal = model_refusal(status, model_type, name)
-            if refusal is not None:
-                return _coded("model-unavailable", refusal)
+            if not status.get(model_type, {}).get("downloaded"):
+                name = MODELS.get(model_type, {}).get("name", model_type)
+                return _coded("model-unavailable", unavailable_message(name))
             owner = model_gate.new_owner("image-annotations")
             if not model_gate.try_acquire(owner):
                 return model_busy_response()
@@ -655,9 +654,6 @@ class AnnotationRoutesMixin:
                     options,
                     on_skipped=functools.partial(store.release_use, token),
                 )
-            except MissingBackendPackages as exc:
-                # A package gone since the status read (load_model logged it).
-                return _coded("model-unavailable", str(exc))
             except Exception:
                 self.logger.exception("Tag suggestion failed")
                 return _error(

py/api/autotag_routes.py

@@ -102,17 +102,6 @@ def size_label(size: str) -> str:
     return f"{match.group(1)} {match.group(2)}" if match else str(size or "")
 
 
-def package_entry(flags: dict) -> dict:
-    """The public package fields of one status entry (#424): the pip names
-    that cannot be imported, the install command and note (strings or null)."""
-    missing = flags.get("missing_packages") or []
-    text = {
-        key: flags[key] if isinstance(flags.get(key), str) else None
-        for key in ("install_command", "install_note")
-    }
-    return {"missing_packages": [str(name) for name in missing], **text}
-
-
 def public_models(status: dict, loaded_type: Optional[str]) -> dict:
     """Each engine model's public entry: names and sizes from ``MODELS``, the
     flags from ``status``; never a path (``model_path`` is dropped)."""
@@ -133,7 +122,6 @@ def public_models(status: dict, loaded_type: Optional[str]) -> dict:
         for key in ("model_exists", "mmproj_exists"):
             if key in flags:
                 entry[key] = bool(flags[key])
-        entry.update(package_entry(flags))
         models[model_type] = entry
     return models
 
@@ -762,7 +750,6 @@ class AutotagRoutesMixin:
                     "downloaded": bool(
                         (status.get(model_type) or {}).get("downloaded")
                     ),
-                    **package_entry(status.get(model_type) or {}),
                 },
                 "existing": existing,
                 "review_required": existing == "replace_after_review",
@@ -1086,8 +1073,8 @@ class AutotagRoutesMixin:
         return self.db.current_image_tags({locator: fingerprint}).get(locator, [])
 
     async def _suggest_single(self, target, model_type, options, base):
-        from ..autotag import MODELS, MissingBackendPackages, get_autotag_service
-        from .annotation_suggest import model_refusal
+        from ..autotag import MODELS, get_autotag_service
+        from .annotation_suggest import unavailable_message
         from .annotations import _pinned_suggestions, _settled, _submit
 
         try:
@@ -1097,8 +1084,8 @@ class AutotagRoutesMixin:
 
         service = get_autotag_service()
         status = await self._run_in_executor(service.get_models_status)
-        message = model_refusal(status, model_type, MODELS[model_type]["name"])
-        if message is not None:
+        if not (status.get(model_type) or {}).get("downloaded"):
+            message = unavailable_message(MODELS[model_type]["name"])
             return self._coded_error(409, "model-unavailable", message)
         owner = model_gate.new_owner("legacy-single")
         if not model_gate.try_acquire(owner):
@@ -1144,9 +1131,6 @@ class AutotagRoutesMixin:
                     options,
                     on_skipped=functools.partial(store.release_use, capture.token),
                 )
-            except MissingBackendPackages as exc:
-                # A package gone since the status read (load_model logged it).
-                return self._coded_error(409, "model-unavailable", str(exc))
             finally:
                 store.release(capture.token)
         finally:

py/api/collections.py

@@ -1,350 +0,0 @@
-"""Collections (#331): named, hand-picked groups of images.
-
-Routes under ``/prompt_manager/collections``. A file is named by its listing
-identity ``{root_index, root_scope, path}`` (``media_target.py``) and stored
-under the favorites' keys (``_favorite_root_key``, ``_favorite_relative_key``),
-which never leave the server. A stale scope (the sources were reordered) is a
-409 ``source-changed`` before anything is written. Responses are
-``{"success": bool, ...}``; an unexpected failure is a logged 500 with a
-generic message, never the exception text.
-"""
-
-import hmac
-import re
-from functools import wraps
-from typing import Callable
-
-from aiohttp import web
-
-from .images import (
-    _favorite_relative_key,
-    _favorite_root_key,
-    _forbidden,
-    _json_body_or_error,
-    collection_not_found,
-)
-from .media_target import media_target
-from .prompts import bad_request
-
-try:
-    from ...database.image_collections import (
-        CollectionFilesMissing,
-        CollectionInvalid,
-        CollectionMissing,
-        CollectionNameTaken,
-        normalize_collection_name,
-    )
-    from ...database.image_favorites import MAX_KEY_LENGTH
-except ImportError:
-    from database.image_collections import (
-        CollectionFilesMissing,
-        CollectionInvalid,
-        CollectionMissing,
-        CollectionNameTaken,
-        normalize_collection_name,
-    )
-    from database.image_favorites import MAX_KEY_LENGTH
-
-BASE = "/prompt_manager/collections"
-# The most files one add or remove names (the bulk tagging cap, MC12).
-MAX_ITEMS = 500
-MAX_ID = 999_999_999
-_PATH_ID = re.compile(r"[1-9][0-9]{0,8}")
-_ROOT_INDEX = re.compile(r"[0-9]{1,9}")
-_ADD_TARGETS = (frozenset({"collection_id", "items"}), frozenset({"name", "items"}))
-_REMOVE_FIELDS = frozenset({"collection_id", "items"})
-_RENAME_FIELDS = frozenset({"name"})
-_MEDIA_MESSAGE = "Only media files can be added to a collection"
-READ_FAILED = "Collections could not be read."
-CHANGE_FAILED = "The collection could not be changed."
-SOURCES_CHANGED = "The sources changed. Refresh the images and try again."
-FILES_NOT_FOUND = (
-    "None of the selected images could be found. Refresh the images and try again."
-)
-NAME_TAKEN = "Another collection already has this name."
-
-
-class _Refused(Exception):
-    """A request refused before any write; carries its response."""
-
-    def __init__(self, response: web.Response):
-        super().__init__(response.status)
-        self.response = response
-
-
-def _coded(status: int, code: str, message: str, **extra) -> web.Response:
-    return web.json_response(
-        {"success": False, "code": code, "error": message, **extra},
-        status=status,
-        headers={"Cache-Control": "no-store"},
-    )
-
-
-def _collection_response(failure: str) -> Callable:
-    """Map the database's refusals to their status; anything else to a 500."""
-
-    def decorate(handler: Callable) -> Callable:
-        @wraps(handler)
-        async def wrapped(self, request: web.Request) -> web.Response:
-            try:
-                return await handler(self, request)
-            except _Refused as refused:
-                return refused.response
-            except CollectionInvalid as exc:
-                return bad_request(str(exc))
-            except CollectionMissing:
-                return collection_not_found()
-            except CollectionFilesMissing:
-                return _coded(404, "files-not-found", FILES_NOT_FOUND)
-            except CollectionNameTaken as exc:
-                return _coded(
-                    409, "name-taken", NAME_TAKEN, collection_id=exc.collection_id
-                )
-            except Exception:
-                self.logger.exception("Collection request failed")
-                return web.json_response(
-                    {"success": False, "error": failure}, status=500
-                )
-
-        return wrapped
-
-    return decorate
-
-
-def _path_id(request: web.Request) -> int:
-    raw = request.match_info["collection_id"]
-    if not raw.isascii() or _PATH_ID.fullmatch(raw) is None:
-        raise _Refused(bad_request("Invalid collection id"))
-    return int(raw)
-
-
-def _body_id(value: object) -> int:
-    if type(value) is not int or not 1 <= value <= MAX_ID:
-        raise _Refused(bad_request("Invalid collection id"))
-    return value
-
-
-async def _body(request: web.Request, allowed: tuple) -> dict:
-    data, error = await _json_body_or_error(request)
-    if error is not None:
-        raise _Refused(error)
-    if frozenset(data) not in allowed:
-        names = " or ".join(", ".join(sorted(fields)) for fields in allowed)
-        raise _Refused(bad_request(f"Request must contain exactly {names}"))
-    return data
-
-
-class CollectionRoutesMixin:
-    """Mixin providing the collection routes (#331)."""
-
-    def _register_collection_routes(self, routes: web.RouteTableDef) -> None:
-        # The fixed paths go first: "/items" must never match "/{collection_id}".
-        routes.get(BASE)(self.list_collections)
-        routes.post(BASE + "/items")(self.add_collection_items)
-        routes.delete(BASE + "/items")(self.remove_collection_items)
-        routes.get(BASE + "/membership")(self.collection_membership)
-        routes.patch(BASE + "/{collection_id}")(self.rename_collection)
-        routes.delete(BASE + "/{collection_id}")(self.delete_collection)
-
-    # -- reads -------------------------------------------------------------
-
-    @_collection_response(READ_FAILED)
-    async def list_collections(self, request: web.Request) -> web.Response:
-        """Every collection with its listed ``count`` and its ``missing`` rows.
-
-        ``count`` is the members listed under every configured source (one
-        primary-key range read per source, matched against its cached
-        listing); ``missing`` the stored rows beyond it. When a scan or a read
-        fails both are null for every collection and the names still return.
-        """
-        collections = await self._run_in_executor(self.db.list_collections)
-        counts = None
-        if collections:
-            try:
-                counts = await self._collection_counts()
-            except Exception:
-                self.logger.warning(
-                    "Collection counts could not be read", exc_info=True
-                )
-        rows = []
-        for collection in collections:
-            listed, stored = (None, None) if counts is None else counts
-            count = None if listed is None else listed.get(collection["id"], 0)
-            stored_rows = None if stored is None else stored.get(collection["id"], 0)
-            rows.append(
-                {
-                    **collection,
-                    "count": count,
-                    # Clamped: never below zero, whatever the snapshot saw.
-                    "missing": None if count is None else max(0, stored_rows - count),
-                }
-            )
-        return web.json_response({"success": True, "collections": rows})
-
-    async def _collection_counts(self) -> tuple[dict, dict]:
-        """``({id: listed members}, {id: stored rows})`` over every source.
-
-        The scans come from the gallery cache; the root keys (realpath), the
-        listings and one read snapshot of every member and stored count run
-        in the executor, so a write between two reads cannot skew them.
-        """
-        roots = list(self._get_all_output_dirs())
-        root_keys = await self._run_in_executor(
-            lambda: [_favorite_root_key(root) for root in roots]
-        )
-        distinct = {}  # one folder configured twice counts once
-        for root, root_key in zip(roots, root_keys):
-            distinct.setdefault(root_key, root)
-        scans = {
-            root_key: await self._get_gallery_files(root)
-            for root_key, root in distinct.items()
-        }
-        return await self._run_in_executor(self._count_members, distinct, scans)
-
-    def _count_members(self, roots: dict, scans: dict) -> tuple[dict, dict]:
-        """Blocking: match one snapshot's members against each listing."""
-        members, stored = self.db.collection_count_snapshot(list(roots))
-        listed: dict[int, int] = {}
-        for root_key, root in roots.items():
-            listing = self._favorite_listing(root, scans[root_key])
-            for collection_id, keys in members.get(root_key, {}).items():
-                found = sum(1 for key in keys if key in listing)
-                listed[collection_id] = listed.get(collection_id, 0) + found
-        return listed, stored
-
-    @_collection_response(READ_FAILED)
-    async def collection_membership(self, request: web.Request) -> web.Response:
-        """GET ``?root_index&root_scope&path``: the ids holding that file."""
-        query = request.query
-        if len(query) != 3 or set(query) != {"root_index", "root_scope", "path"}:
-            # len() counts a repeated key (?path=a&path=b) twice.
-            return bad_request("Query must name root_index, root_scope and path once")
-        raw_index = query["root_index"]
-        if not raw_index.isascii() or _ROOT_INDEX.fullmatch(raw_index) is None:
-            return bad_request("Invalid gallery root")
-        roots = list(self._get_all_output_dirs())
-        target = {
-            "root_index": int(raw_index),
-            "root_scope": query["root_scope"],
-            "path": query["path"],
-        }
-        root_key, key = await self._run_in_executor(
-            self._collection_key, target, roots, {}
-        )
-        ids = await self._run_in_executor(self.db.file_collections, root_key, key)
-        return web.json_response({"success": True, "collection_ids": ids})
-
-    # -- writes ------------------------------------------------------------
-
-    @_collection_response(CHANGE_FAILED)
-    async def add_collection_items(self, request: web.Request) -> web.Response:
-        """POST ``{collection_id | name, items}``: add the listed files.
-
-        Only files the source's listing holds are added; the rest count in
-        ``not_found``. A new name with nothing to add creates nothing (404
-        ``files-not-found``).
-        """
-        data = await _body(request, _ADD_TARGETS)
-        target = {}
-        if "name" in data:
-            target["name"] = normalize_collection_name(data["name"])
-        else:
-            target["collection_id"] = _body_id(data["collection_id"])
-        roots = list(self._get_all_output_dirs())
-        keys = await self._run_in_executor(self._collection_items, data["items"], roots)
-        found, not_found = [], 0
-        listings = {}
-        for index, root_key, key in keys:
-            if index not in listings:
-                root = roots[index]
-                files = await self._get_gallery_files(root)
-                listings[index] = await self._run_in_executor(
-                    self._favorite_listing, root, files
-                )
-            if key in listings[index]:
-                found.append((root_key, key))
-            else:
-                not_found += 1
-        result = await self._run_in_executor(
-            lambda: self.db.add_to_collection(items=found, **target)
-        )
-        return web.json_response({"success": True, **result, "not_found": not_found})
-
-    @_collection_response(CHANGE_FAILED)
-    async def remove_collection_items(self, request: web.Request) -> web.Response:
-        """DELETE ``{collection_id, items}``: listed or not, every named file."""
-        data = await _body(request, (_REMOVE_FIELDS,))
-        collection_id = _body_id(data["collection_id"])
-        roots = list(self._get_all_output_dirs())
-        keys = await self._run_in_executor(self._collection_items, data["items"], roots)
-        result = await self._run_in_executor(
-            self.db.remove_from_collection,
-            collection_id,
-            [(root_key, key) for _index, root_key, key in keys],
-        )
-        return web.json_response({"success": True, **result})
-
-    @_collection_response(CHANGE_FAILED)
-    async def rename_collection(self, request: web.Request) -> web.Response:
-        """PATCH ``{name}``: a case variant of its own name is allowed."""
-        collection_id = _path_id(request)
-        data = await _body(request, (_RENAME_FIELDS,))
-        name = normalize_collection_name(data["name"])
-        collection = await self._run_in_executor(
-            self.db.rename_collection, collection_id, name
-        )
-        return web.json_response({"success": True, "collection": collection})
-
-    @_collection_response(CHANGE_FAILED)
-    async def delete_collection(self, request: web.Request) -> web.Response:
-        """DELETE: the collection and its members; files are never touched."""
-        collection_id = _path_id(request)
-        await self._run_in_executor(self.db.delete_collection, collection_id)
-        return web.json_response({"success": True, "deleted": True})
-
-    # -- request steps -----------------------------------------------------
-
-    def _collection_items(self, items: object, roots: list) -> list[tuple]:
-        """``(index, root key, relative key)`` per distinct file, in order.
-
-        Blocking (realpath per root, once per request): run in the executor.
-        Every item is checked before anything is written: 400 for a malformed
-        shape, 403 for an unsafe path, 409 for a stale scope. Two spellings
-        that fold to one key (Windows) count once.
-        """
-        if not isinstance(items, list) or not 1 <= len(items) <= MAX_ITEMS:
-            raise _Refused(bad_request(f"items must list 1 to {MAX_ITEMS} images"))
-        keys, sources = {}, {}
-        for item in items:
-            index = item.get("root_index") if isinstance(item, dict) else None
-            root_key, key = self._collection_key(item, roots, sources)
-            keys.setdefault((root_key, key), index)
-        return [(index, root_key, key) for (root_key, key), index in keys.items()]
-
-    def _collection_key(
-        self, item: object, roots: list, sources: dict
-    ) -> tuple[str, str]:
-        """The stored keys of one target, or raise its refusal (blocking).
-
-        *sources* caches ``{index: (scope, root key)}`` for one request, so
-        each root's realpath runs once however many items name it.
-        """
-        target, error = media_target(item, media_message=_MEDIA_MESSAGE)
-        if error is not None:
-            raise _Refused(error)
-        index, scope, relative = target
-        if index >= len(roots):
-            raise _Refused(_coded(409, "source-changed", SOURCES_CHANGED))
-        if index not in sources:
-            sources[index] = (
-                self._gallery_root_scope(roots[index], index),
-                _favorite_root_key(roots[index]),
-            )
-        current, root_key = sources[index]
-        if not hmac.compare_digest(scope, current):
-            raise _Refused(_coded(409, "source-changed", SOURCES_CHANGED))
-        key = _favorite_relative_key(relative)
-        if max(len(root_key), len(key)) > MAX_KEY_LENGTH:
-            # A stored key past the schema bound would fail the next restore.
-            raise _Refused(_forbidden("Path is too long to add to a collection"))
-        return root_key, key

py/api/duplicate_files.py

@@ -588,9 +588,7 @@ class DuplicateFilesMixin:
         job.update(total=len(targets), status_line="Removing duplicate files")
         spellings = await self._run_in_executor(self._source_spellings)
         removed, failure, keepers = 0, None, {}
-        totals = dict.fromkeys(
-            ("moved", "merged", "favorites", "tags", "review", "collections"), 0
-        )
+        totals = dict.fromkeys(("moved", "merged", "favorites", "tags", "review"), 0)
         totals["categories"] = 0  # image categories kept on the kept copies (#332)
         for done, target in enumerate(targets, start=1):
             if failure is not None:
@@ -634,11 +632,6 @@ class DuplicateFilesMixin:
             job.log_line(
                 f"Moved {_plural(totals['favorites'], 'favorite')} to the kept copies"
             )
-        if totals["collections"]:
-            job.log_line(
-                f"Moved {_plural(totals['collections'], 'collection membership')} "
-                "to the kept copies"
-            )
         if totals["tags"]:
             job.log_line(
                 f"Added {_plural(totals['tags'], 'image tag')} to the kept copies"

py/api/duplicate_spellings.py

@@ -104,8 +104,7 @@ def copy_move(target, kept_stat, spellings):
 
     A record found under a folder spelling moves to the kept copy under
     the same spelling when that folder holds it too, else to its real
-    path. Its favorite and its collection memberships move under every
-    listed root holding the file.
+    path. Its favorite moves under every listed root holding the file.
     """
     removed = spellings.of(target["abs"])
     kept = spellings.of(target["keeper_abs"])

py/api/image_tag_jobs.py

@@ -42,7 +42,7 @@ from .. import model_gate
 from .admin import _plural, _time_left
 from .annotation_suggest import (
     OptionError,
-    model_refusal,
+    unavailable_message,
     validate_options,
 )
 from .annotations import (
@@ -58,9 +58,7 @@ from .annotations import (
 from .autotag_routes import BATCH_CANCELLED, MODEL_BUSY_ERROR, model_busy_response
 from .images import (
     MAX_LISTING_SELECTION,
-    CollectionMissing,
     ListingSourceChanged,
-    collection_not_found,
     _current_fingerprint,
     _listing_posix,
     _public_path,
@@ -512,8 +510,10 @@ class ImageTagJobsMixin:
             )
         )
         label = MODELS[model_type]["label"]
-        message = model_refusal(status, model_type, label)
-        if message is not None:
+        if not (status.get(model_type) or {}).get("downloaded"):
+            message = (
+                f"{label} is not downloaded. Download it in System › Auto-tagging."
+            )
             return None, _refusal(409, "model-unavailable", message)
         if backup_on and short is not None:
             return None, _refusal(507, "insufficient-space", short_space_message(short))
@@ -689,8 +689,6 @@ class ImageTagJobsMixin:
             selection = await self.resolve_listing_filter(spec.filter, cap)
         except ListingSourceChanged:
             return None, _coded("source-changed")
-        except CollectionMissing:
-            return None, collection_not_found()
         except ValueError as exc:
             return None, bad_request(str(exc))
         except Exception:
@@ -790,13 +788,13 @@ class ImageTagJobsMixin:
 
     async def _prepare_tagging_model(self, job, spec: _Spec, owner):
         """The loaded service, or None (logged) when the job cannot run."""
-        from ..autotag import MODELS, MissingBackendPackages, get_autotag_service
+        from ..autotag import MODELS, get_autotag_service
 
         service = get_autotag_service()
         status = await self._run_in_executor(service.get_models_status)
-        name = MODELS.get(spec.model_type, {}).get("name", spec.model_type)
-        message = model_refusal(status, spec.model_type, name)
-        if message is not None:
+        if not status.get(spec.model_type, {}).get("downloaded"):
+            name = MODELS.get(spec.model_type, {}).get("name", spec.model_type)
+            message = unavailable_message(name)
             job.update(status_line=message)
             job.log_line(f"! {message}")
             return None
@@ -808,11 +806,6 @@ class ImageTagJobsMixin:
                 spec.model_type,
                 spec.options["use_gpu"],
             )
-        except MissingBackendPackages as exc:
-            # A package gone since the status read (load_model logged it).
-            job.update(status_line=str(exc))
-            job.log_line(f"! {exc}")
-            return None
         except Exception:
             self.logger.exception("The auto-tag job could not load its model")
             job.update(status_line=INFERENCE_FAILED)

py/api/images.py

@@ -18,7 +18,7 @@ import urllib.parse
 from bisect import bisect_left, bisect_right, insort
 from collections.abc import Mapping
 from pathlib import Path
-from typing import Callable, Iterable, NamedTuple
+from typing import Callable, NamedTuple
 
 from aiohttp import web
 from PIL import Image, UnidentifiedImageError
@@ -58,7 +58,6 @@ from .inspection_service import (
 )
 
 try:
-    from ...database.image_collections import CollectionMissing
     from ...database.image_favorites import MAX_KEY_LENGTH
     from ...database.library import display_title
     from ...database.models import normalize_image_path
@@ -82,7 +81,6 @@ try:
         reveal_in_file_manager,
     )
 except ImportError:
-    from database.image_collections import CollectionMissing
     from database.image_favorites import MAX_KEY_LENGTH
     from database.library import display_title
     from database.models import normalize_image_path
@@ -112,21 +110,6 @@ IMAGE_EXTENSIONS = _IMAGE_EXTENSIONS
 _CARD_RECORDS = ("prompt", "workflow")
 _PNG_SIGNATURE = b"\x89PNG\r\n\x1a\n"
 _LISTING_FAILED = "The image list could not be filtered. Check server logs for details."
-_COLLECTION_ID = re.compile(r"[1-9][0-9]{0,8}")
-COLLECTION_NOT_FOUND = "That collection no longer exists."
-
-
-def collection_not_found() -> web.Response:
-    """The 404 a write or a listing answers for an unknown collection (#331)."""
-    return web.json_response(
-        {
-            "success": False,
-            "code": "collection-not-found",
-            "error": COLLECTION_NOT_FOUND,
-        },
-        status=404,
-        headers={"Cache-Control": "no-store"},
-    )
 
 
 def _card_header(path: Path) -> tuple:
@@ -1127,9 +1110,8 @@ def _workspace_filters(query: Mapping) -> dict:
     the linked positive's text, title and tag names. ``category`` is exact,
     ``tags`` is a comma list that must all be present, ``sort=rating`` ranks by
     the linked positive, and ``favorites=1`` keeps only favorites (the
-    Favorites page, #249 D51). ``collection=<id>`` (1 to 9 digits) keeps only
-    that collection's members (#331); it wins over ``favorites`` (a page never
-    sets both). Raises ValueError for any unknown or oversized value.
+    Favorites page, #249 D51). Raises ValueError for any unknown or oversized
+    value.
     """
     text = query.get("q", "").strip()
     folded = text.casefold()
@@ -1143,10 +1125,8 @@ def _workspace_filters(query: Mapping) -> dict:
         {tag.strip() for tag in query.get("tags", "").split(",") if tag.strip()}
     )
     favorites = query.get("favorites", "0")
-    collection = query.get("collection", "")
     if (
         favorites not in ("0", "1")
-        or (collection != "" and _COLLECTION_ID.fullmatch(collection) is None)
         or len(text) > 500
         or len(folded) > 500
         or media not in ("all", "image", "video")
@@ -1169,8 +1149,7 @@ def _workspace_filters(query: Mapping) -> dict:
         "path": exact.casefold(),
         "category": category,
         "tags": tags,
-        "favorites": favorites == "1" and not collection,
-        "collection": int(collection) if collection else None,
+        "favorites": favorites == "1",
     }
 
 
@@ -1188,8 +1167,6 @@ LISTING_FILTER_KEYS = frozenset(
         "media",
         "sort",
         "favorites",
-        # A collection page's filter (#331): bulk actions act on its members.
-        "collection",
     }
 )
 MAX_LISTING_FILTER_VALUE = 2048
@@ -1246,7 +1223,7 @@ def _admitted_entries(
     entries: list,
     filters: dict,
     links: dict | None,
-    members: frozenset | None = None,
+    favorites: frozenset | None = None,
     image_tags: dict | None = None,
     own_categories: dict | None = None,
 ):
@@ -1259,11 +1236,11 @@ def _admitted_entries(
     admits a file whose effective category equals it (#332 MC5): its own
     category (*own_categories*, ``{normalized path: category}``) when it has one,
     else the inherited one, so an unlinked file with its own category is
-    admitted. *members*, when given, admits only those listed paths (the
-    favorites of ``favorites=1`` or a ``collection``'s members). *image_tags*
-    maps normalized paths to their _ImageTagMatch: a tag filter also admits a
-    file whose current image tags (with its linked positive's tags) carry every
-    tag, and ``q`` also admits an image tag name hit.
+    admitted. *favorites*, when given, admits only those listed
+    paths (``favorites=1``). *image_tags* maps normalized paths to their
+    _ImageTagMatch: a tag filter also admits a file whose current image tags
+    (with its linked positive's tags) carry every tag, and ``q`` also admits an
+    image tag name hit.
     """
     query, media, folder = filters["query"], filters["media"], filters["folder"]
     category = filters["category"]
@@ -1281,7 +1258,7 @@ def _admitted_entries(
             continue
         if media != "all" and (media == "video") != entry.video:
             continue
-        if members is not None and entry.path not in members:
+        if favorites is not None and entry.path not in favorites:
             continue
         match = None if links is None else links.get(entry.normalized)
         image = None if image_tags is None else image_tags.get(entry.normalized)
@@ -1309,7 +1286,7 @@ def _filtered_page(
     size: int,
     filters: dict,
     links: dict | None,
-    members: frozenset | None = None,
+    favorites: frozenset | None = None,
     image_tags: dict | None = None,
     own_categories: dict | None = None,
 ) -> tuple[int, list, int | None]:
@@ -1321,7 +1298,7 @@ def _filtered_page(
     """
     total, page, positives = 0, [], set()
     for position, entry, match in _admitted_entries(
-        entries, filters, links, members, image_tags, own_categories
+        entries, filters, links, favorites, image_tags, own_categories
     ):
         total += 1
         if match is not None:
@@ -2025,7 +2002,6 @@ class ImageRoutesMixin:
                         filters["category"],
                         filters["tags"],
                         filters["favorites"],
-                        filters["collection"],
                     ]
                 ).encode()
             ).hexdigest()
@@ -2036,19 +2012,17 @@ class ImageRoutesMixin:
         except ValueError as exc:
             return bad_request(str(exc))
 
+        listings = [
+            (index, root, await self._get_gallery_files(root))
+            for index, root in enumerate(output_dirs)
+            if root_index is None or index == root_index
+        ]
         try:
-            if filters["collection"] is not None and not await self._run_in_executor(
-                self.db.collection_exists, filters["collection"]
-            ):
-                raise CollectionMissing("No such collection")
-            listings = await self._workspace_listings(output_dirs, root_index)
             page, total, has_more, next_cursor, positive_count = (
                 await self._run_in_executor(
                     self._select_workspace_page, listings, filters, after, limit, scope
                 )
             )
-        except CollectionMissing:
-            return collection_not_found()
         except Exception:
             # A filter that needs the prompt links or the image tags cannot be
             # served without them. Never echo the exception: it can carry SQL
@@ -2308,11 +2282,9 @@ class ImageRoutesMixin:
     ) -> tuple:
         """The ordered entries and what admits them (blocking; run in executor).
 
-        Returns ``(entries, key, links, image_tags, members, own)``: the
+        Returns ``(entries, key, links, image_tags, favorites, own)``: the
         listing in the filters' order, its keyset key, and the link, image-tag,
-        member and own-category maps _admitted_entries reads (members: a
-        collection's, else the favorites, else None). A collection deleted since
-        the route checked it raises CollectionMissing. One SELECT
+        favorite and own-category maps _admitted_entries reads. One SELECT
         (get_image_link_matches) reads every linked positive when *read_links*;
         under a category it keeps only links whose raw recipe or positive
         category is that value (the inherited one is decided in Python), and
@@ -2396,14 +2368,10 @@ class ImageRoutesMixin:
             def key(entry):
                 return _workspace_key(entry, order)
 
-        return (
-            entries,
-            key,
-            links,
-            image_tags,
-            self._workspace_members(listings, filters),
-            own,
+        favorites = (
+            self._workspace_favorite_paths(listings) if filters["favorites"] else None
         )
+        return entries, key, links, image_tags, favorites, own
 
     def _own_category_links(self, links: dict, own: dict, filters: dict) -> dict:
         """*links* plus the links of files whose own category is the filter's.
@@ -2455,7 +2423,7 @@ class ImageRoutesMixin:
             or bool(filters["tags"])
             or order == "rating"
         )
-        entries, key, links, image_tags, members, own = self._workspace_admission(
+        entries, key, links, image_tags, favorites, own = self._workspace_admission(
             listings, filters, read_links=needed or after is None
         )
         start = 0
@@ -2466,7 +2434,7 @@ class ImageRoutesMixin:
             else:
                 start = bisect_right(entries, after, key=key)
         total, page, positive_count = _filtered_page(
-            entries, start, limit + 1, filters, links, members, image_tags, own
+            entries, start, limit + 1, filters, links, favorites, image_tags, own
         )
         if not needed and after is not None:
             positive_count = _COUNT_OMITTED
@@ -2488,12 +2456,12 @@ class ImageRoutesMixin:
 
         The links are read strictly: the positives must be the listing's own.
         """
-        entries, _key, links, image_tags, members, own = self._workspace_admission(
+        entries, _key, links, image_tags, favorites, own = self._workspace_admission(
             listings, filters, read_links=True, strict=True
         )
         targets, positives, unlinked, scopes = [], {}, 0, {}
         for _position, entry, match in _admitted_entries(
-            entries, filters, links, members, image_tags, own
+            entries, filters, links, favorites, image_tags, own
         ):
             if len(targets) == cap:
                 return ListingSelection(targets, list(positives), unlinked, True)
@@ -2515,11 +2483,9 @@ class ImageRoutesMixin:
     ) -> ListingSelection:
         """The images a parse_listing_filter result admits right now (#392).
 
-        Raises ValueError for a root outside the current roots,
+        Raises ValueError for a root outside the current roots, and
         ListingSourceChanged when the filter's ``root_scope`` no longer names
-        its root (the sources were renumbered since the listing), and
-        CollectionMissing when its ``collection`` no longer exists (checked
-        before any scan and again after the members are read).
+        its root (the sources were renumbered since the listing).
         """
         output_dirs = list(self._get_all_output_dirs())
         root_index = _workspace_root(params, output_dirs)
@@ -2529,11 +2495,11 @@ class ImageRoutesMixin:
                 raise ListingSourceChanged()
             raise ValueError("Invalid gallery root scope")
         filters = _workspace_filters(params)
-        if filters["collection"] is not None and not await self._run_in_executor(
-            self.db.collection_exists, filters["collection"]
-        ):
-            raise CollectionMissing("No such collection")
-        listings = await self._workspace_listings(output_dirs, root_index)
+        listings = [
+            (index, root, await self._get_gallery_files(root))
+            for index, root in enumerate(output_dirs)
+            if root_index is None or index == root_index
+        ]
         return await self._run_in_executor(
             self._select_workspace_matches, listings, filters, cap
         )
@@ -3718,58 +3684,25 @@ class ImageRoutesMixin:
         self._favorite_listing_cache[cache_key] = (files, listing)
         return listing
 
-    def _workspace_members(self, listings: list[tuple], filters: dict):
-        """The member set the filters ask for, or None (blocking)."""
-        collection = filters.get("collection")
-        if collection is not None:
-            members = self._workspace_member_paths(
-                listings,
-                lambda root_key: self.db.collection_members(collection, root_key),
-            )
-            # Checked after the reads: a collection deleted before or while
-            # they ran is a 404, never an empty page passing for it.
-            if not self.db.collection_exists(collection):
-                raise CollectionMissing("No such collection")
-            return members
-        if filters["favorites"]:
-            return self._workspace_favorite_paths(listings)
-        return None
-
     def _workspace_favorite_paths(self, listings: list[tuple]) -> frozenset:
-        """The listed paths of every favorite in the selected roots (blocking)."""
-        return self._workspace_member_paths(listings, self.db.get_root_favorites)
+        """The listed paths of every favorite in the selected roots (blocking).
 
-    def _workspace_member_paths(
-        self, listings: list[tuple], keys_for_source: Callable[[str], Iterable[str]]
-    ) -> frozenset:
-        """The listed paths of the stored keys of each selected root (blocking).
-
-        One read per root (``keys_for_source(root key)``: the favorites' or a
-        collection's primary-key range), matched against the root's cached
-        ``{relative key: listing spelling}``, so the work follows the members
-        rather than the files, and a key folds case exactly as it was stored
-        (Windows). A member whose file is gone matches nothing. A failed read
-        raises: an unfiltered page must never pass for the members.
+        One primary-key read per root (get_root_favorites), matched against the
+        root's cached ``{relative key: listing spelling}``, so the work follows
+        the favorites rather than the files, and a key folds case exactly as
+        the toggle stored it (Windows). A favorite whose file is gone matches
+        nothing. A failed read raises: an unfiltered page must never pass for
+        the favorites.
         """
         paths = set()
         for _index, root, files in listings:
             listing = self._favorite_listing(root, files)
-            for key in keys_for_source(_favorite_root_key(root)):
+            for key in self.db.get_root_favorites(_favorite_root_key(root)):
                 listed = listing.get(key)
                 if listed is not None:
                     paths.add(root / listed)
         return frozenset(paths)
 
-    async def _workspace_listings(
-        self, output_dirs: list[Path], root_index: int | None
-    ) -> list[tuple]:
-        """``(index, root, scan)`` of every selected root (cached scans)."""
-        return [
-            (index, root, await self._get_gallery_files(root))
-            for index, root in enumerate(output_dirs)
-            if root_index is None or index == root_index
-        ]
-
     def _workspace_favorites(self, page: list[tuple]) -> set[tuple[int, str]]:
         """``(root index, listing path)`` of the favorites among *page* entries."""
         by_root: dict[tuple[int, Path], dict[str, str]] = {}

py/api/prompts.py

@@ -1227,9 +1227,7 @@ class PromptRoutesMixin:
         """
         from .images import (
             MAX_LISTING_SELECTION,
-            CollectionMissing,
             ListingSourceChanged,
-            collection_not_found,
             parse_listing_filter,
         )
 
@@ -1254,8 +1252,6 @@ class PromptRoutesMixin:
                 },
                 status=409,
             )
-        except CollectionMissing:
-            return collection_not_found()
         except ValueError as exc:
             return refused(str(exc))
         if selection.truncated:

py/autotag.py

@@ -7,7 +7,6 @@ Refactored from standalone_tagger.py for integration with PromptManager API.
 
 import errno
 import gc
-import importlib.util
 import inspect
 import os
 import sys
@@ -156,91 +155,6 @@ MODELS = {
     },
 }
 
-# The Python modules each backend imports when it loads, with their pip names
-# (#424). None of them is a PromptManager requirement: they are optional, and
-# llama-cpp-python needs a build for the user's GPU. Nothing is ever installed.
-BACKEND_PACKAGES: Dict[str, Tuple[Tuple[str, str], ...]] = {
-    "gguf": (("llama_cpp", "llama-cpp-python"),),
-    # The default 8-bit load needs bitsandbytes, and device_map needs accelerate.
-    "hf": (
-        ("torch", "torch"),
-        ("transformers", "transformers"),
-        ("accelerate", "accelerate"),
-        ("bitsandbytes", "bitsandbytes"),
-    ),
-    "wd14-swinv2": (("onnxruntime", "onnxruntime"),),
-    "wd14-vit": (("onnxruntime", "onnxruntime"),),
-}
-_INSTALL_NOTES = {
-    "gguf": (
-        'For a CUDA build: CMAKE_ARGS="-DGGML_CUDA=on" pip install llama-cpp-python'
-    ),
-    "wd14-swinv2": "Use onnxruntime-gpu for CUDA.",
-    "wd14-vit": "Use onnxruntime-gpu for CUDA.",
-}
-_PIP_NAMES = {
-    module: pip for packages in BACKEND_PACKAGES.values() for module, pip in packages
-}
-
-
-def _importable(module: str) -> bool:
-    """Whether *module* (a top-level name) can be imported; imports nothing."""
-    if sys.modules.get(module) is not None:
-        return True
-    try:
-        return importlib.util.find_spec(module) is not None
-    except (ImportError, ValueError, OSError):
-        return False
-
-
-def missing_packages(model_type: str) -> List[str]:
-    """The pip names of the packages *model_type* needs and cannot import."""
-    return [
-        pip
-        for module, pip in BACKEND_PACKAGES.get(model_type, ())
-        if not _importable(module)
-    ]
-
-
-def package_fields(model_type: str, missing: List[str]) -> Dict[str, Any]:
-    """The status fields of *missing*: pip names, install command and note."""
-    missing = list(missing)
-    return {
-        "missing_packages": missing,
-        "install_command": "pip install " + " ".join(missing) if missing else None,
-        "install_note": _INSTALL_NOTES.get(model_type) if missing else None,
-    }
-
-
-def _joined(names: List[str]) -> str:
-    if len(names) <= 1:
-        return "".join(names)
-    return ", ".join(names[:-1]) + " and " + names[-1]
-
-
-def missing_packages_message(model_type: str, missing: List[str]) -> str:
-    """The one sentence every refusal of a model with missing packages uses."""
-    label = MODELS.get(model_type, {}).get("label", model_type)
-    fields = package_fields(model_type, missing)
-    pronoun = "it" if len(missing) == 1 else "them"
-    message = (
-        f"{label} needs {_joined(missing)}. Install {pronoun} into ComfyUI's "
-        f"Python: {fields['install_command']}."
-    )
-    if fields["install_note"]:
-        message += " " + fields["install_note"]
-    return message
-
-
-class MissingBackendPackages(RuntimeError):
-    """A model whose backend packages cannot be imported (#424)."""
-
-    def __init__(self, model_type: str, missing: List[str]):
-        self.model_type = model_type
-        self.missing = list(missing)
-        super().__init__(missing_packages_message(model_type, self.missing))
-
-
 # Default prompts
 DEFAULT_PROMPT = DEFAULT_TAG_TEMPLATE
 
@@ -253,10 +167,6 @@ SYSTEM_PROMPT = (
 )
 
 
-def _none(_model_type: str) -> List[str]:
-    return []
-
-
 def _load_rgb(image_path: str) -> Image.Image:
     """Decode the image as RGB and close the file before inference.
 
@@ -293,7 +203,6 @@ class AutoTagService:
         self,
         models_dir: Optional[Path] = None,
         model_loader: Optional[ModelLoader] = None,
-        package_probe: Optional[Callable[[str], List[str]]] = None,
     ):
         """Initialize the AutoTag service.
 
@@ -304,16 +213,9 @@ class AutoTagService:
                        ``(kind, backend)`` tuple used by ``generate_tags``.
                        Defaults to ``_load_model``, which imports the ML
                        backends lazily. Tests inject a fake here.
-            package_probe: Callable ``(model_type)`` returning the pip names
-                       of the backend packages that cannot be imported.
-                       Defaults to ``missing_packages`` with the default
-                       loader; an injected loader brings its own backend.
         """
         self.logger = get_logger("autotag.service")
         self._model_loader: ModelLoader = model_loader or self._load_model
-        if package_probe is None:
-            package_probe = missing_packages if model_loader is None else _none
-        self._package_probe = package_probe
 
         # Determine models directory
         if models_dir:
@@ -418,9 +320,6 @@ class AutoTagService:
                     # Get the actual path (local or cache)
                     model_status["model_path"] = str(self._get_hf_model_path())
 
-            model_status.update(
-                package_fields(model_type, self._package_probe(model_type))
-            )
             status[model_type] = model_status
 
         return status
@@ -556,9 +455,13 @@ class AutoTagService:
 
     def _load_wd14_tagger(self, model_type: str, use_gpu: bool = True):
         """Load WD14 ONNX model and tag list."""
-        # A missing onnxruntime is refused by load_model before this runs
-        # (#424); a ModuleNotFoundError here becomes the same refusal.
-        import onnxruntime as ort
+        try:
+            import onnxruntime as ort
+        except ImportError:
+            raise RuntimeError(
+                "onnxruntime is required for WD14 models. "
+                "Install with: pip install onnxruntime (or onnxruntime-gpu for CUDA)"
+            )
         import csv
 
         config = MODELS[model_type]
@@ -791,7 +694,6 @@ class AutoTagService:
         Raises:
             ValueError: If model_type is invalid
             RuntimeError: If model not downloaded or loading fails
-            MissingBackendPackages: If its backend packages cannot be imported
         """
         if model_type not in MODELS:
             raise ValueError(f"Invalid model type: {model_type}")
@@ -803,11 +705,6 @@ class AutoTagService:
         status = self.get_models_status()
         if not status[model_type]["downloaded"]:
             raise RuntimeError(f"Model {model_type} not downloaded")
-        missing = status[model_type].get("missing_packages") or []
-        if missing:
-            refusal = MissingBackendPackages(model_type, missing)
-            self.logger.warning(str(refusal))
-            raise refusal
 
         try:
             self._tagger = self._model_loader(model_type, use_gpu)
@@ -815,17 +712,6 @@ class AutoTagService:
             self.logger.info(f"Model {model_type} loaded successfully")
             return True
 
-        except ModuleNotFoundError as e:
-            # A package find_spec found but that does not import (a broken
-            # install), or a dependency of one: the same refusal, no traceback.
-            self._tagger = None
-            self._current_model_type = None
-            module = (e.name or "").split(".")[0] or str(e)
-            refusal = MissingBackendPackages(
-                model_type, [_PIP_NAMES.get(module, module)]
-            )
-            self.logger.warning(str(refusal))
-            raise refusal from None
         except Exception as e:
             self.logger.error(f"Failed to load model {model_type}: {e}")
             self._tagger = None

tests/browser/full-inspector.spec.mjs

@@ -724,9 +724,6 @@ test('collection viewer uses real public transforms and resets on navigation',as
 async function slideshowFixture(page,request,preferences={videoAutoplay:false,videoMute:true,videoLoop:false}) {
     await expect(await request.post('/__test__/reset',{data:{full_inspector:true,include_video:true}})).toBeOK();
     await page.goto('/prompt_manager/workspace#/images');
-    // Install the fake clock before the fixture wraps setTimeout: the wrapped timer (which the viewer session captures)
-    // must be the fake one, so page.clock.runFor alone decides when the 3500 ms slideshow deadline fires.
-    await page.clock.install();
     await page.evaluate(async preferences=>{
         if(preferences) localStorage.setItem('gallerySettings',JSON.stringify(preferences));
         const [{createMediaViewer},{createInspectionController},{createScope},{createPromptSender}]=await Promise.all([
@@ -746,7 +743,7 @@ async function slideshowFixture(page,request,preferences={videoAutoplay:false,vi
     },preferences);
     await expect(mediaDialog(page).getByRole('button',{name:'Zoom in',exact:true})).toHaveAttribute('aria-disabled','false');
     await expect(mediaDialog(page).locator('#viewer-details > div > p.small')).toHaveText('complete.png');
-    await page.clock.pauseAt(new Date(Date.now()+1000));
+    await page.clock.install();await page.clock.pauseAt(new Date(Date.now()+1000));
 }
 const slideshowButton=page=>mediaDialog(page).locator('#viewer-toolbar').getByRole('button',{name:/^(Play|Pause|Stop) slideshow$/});
 const timerCount=page=>page.evaluate(()=>window.slideshowTimers.size);

tests/browser/server.py

@@ -75,8 +75,6 @@ class TestModel:
     loaded = None
     # Models the Tag image dialog workflows mark as not downloaded.
     unavailable: set = set()
-    # Pip names per model whose backend packages "cannot be imported" (#424).
-    missing_packages: dict = {}
     # Scored names the concept comparisons answer instead of the fixed list
     # (``/__test__/tagging/suggestions``); None keeps the fixed list.
     suggestions: list | None = None
@@ -84,13 +82,10 @@ class TestModel:
     models_config: dict = {}
 
     def get_models_status(self) -> dict:
-        from py.autotag import package_fields
-
         return {
             name: {
                 "downloaded": name not in self.unavailable,
                 "loaded": self.loaded == name,
-                **package_fields(name, self.missing_packages.get(name, [])),
             }
             for name in self.models_config
         }
@@ -267,8 +262,6 @@ def create_app(root: Path) -> web.Application:
         with target.db.model.get_connection() as conn:
             for table in (
                 "saved_views",
-                "image_collection_items",
-                "image_collections",
                 "image_favorites",
                 "media_review_decisions",
                 "media_review_items",

tests/browser/workspace-system-tagging.spec.mjs

@@ -123,32 +123,6 @@ test('model options are the four real engines with size and the description show
     await expect(actionOf(page, 'Unload')).toBeDisabled();
 });
 
-const NEEDS_LLAMA = 'GGUF JoyCaption needs llama-cpp-python. Install it into ComfyUI\'s Python: pip install llama-cpp-python. '
-    + 'For a CUDA build: CMAKE_ARGS="-DGGML_CUDA=on" pip install llama-cpp-python';
-
-test('a downloaded model whose backend package is missing says so and is not offered as ready (#424)', async ({ page, request }) => {
-    await expect(await request.post('/__test__/tagging/models', { data: { unavailable: ['wd14-vit'],
-        missing_packages: { gguf: ['llama-cpp-python'], 'wd14-vit': ['onnxruntime'] } } })).toBeOK();
-    await openTagging(page);
-    const line = modelRow(page).locator('p').first();
-    await page.locator('#tag-model').selectOption('gguf');
-    await expect(line).toHaveText('Downloaded. Needs llama-cpp-python: pip install llama-cpp-python. '
-        + 'For a CUDA build: CMAKE_ARGS="-DGGML_CUDA=on" pip install llama-cpp-python');
-    // Files and packages are separate: Download (again) stays offered.
-    await expect(actionOf(page, 'Download again')).not.toHaveAttribute('aria-disabled', 'true');
-    // Review explains instead of reviewing; nothing is previewed.
-    await expect(reviewButton(page)).toHaveAttribute('aria-disabled', 'true');
-    await reviewButton(page).dispatchEvent('click');
-    await expect(toast(page)).toHaveText(NEEDS_LLAMA);
-    expect(page.modelCalls.filter(call => call.endsWith('/autotag/batch/preview'))).toEqual([]);
-    // Not downloaded reads differently and still names what it will need.
-    await page.locator('#tag-model').selectOption('wd14-vit');
-    await expect(line).toHaveText('Not downloaded. Download size ~400 MB. Also needs onnxruntime.');
-    await page.locator('#tag-model').selectOption('wd14-swinv2');
-    await expect(line).toHaveText('Downloaded. Not loaded.');
-    await expect(reviewButton(page)).not.toHaveAttribute('aria-disabled', 'true');
-});
-
 test('entering the section makes no model call besides status', async ({ page }) => {
     await openTagging(page);
     await page.locator('#workspace-main .section-nav').getByRole('button', { name: 'Integrations', exact: true }).click();

tests/browser/workspace-tagging-bulk.spec.mjs

@@ -186,26 +186,6 @@ test('a model that is not downloaded keeps Start disabled and says why', async (
     expect(posted).toBe(0);
 });
 
-const NEEDS_LLAMA = 'GGUF JoyCaption needs llama-cpp-python. Install it into ComfyUI\'s Python: pip install llama-cpp-python. '
-    + 'For a CUDA build: CMAKE_ARGS="-DGGML_CUDA=on" pip install llama-cpp-python';
-
-test('a model missing its backend package keeps Start disabled and names the install command (#424)', async ({ page, request }) => {
-    await expect(await request.post('/__test__/tagging/models', { data: { unavailable: [],
-        missing_packages: { gguf: ['llama-cpp-python'] } } })).toBeOK();
-    await select(page, FIRST);
-    await barButton(page, 'Auto-tag selected').click();
-    const status = modal(page).locator('#tag-generation-status');
-    const start = actionButtons(page).last();
-    await modal(page).getByRole('combobox', { name: 'Tagging model', exact: true }).selectOption('gguf');
-    await expect(status).toHaveText(NEEDS_LLAMA);
-    await expect(start).toHaveAttribute('aria-disabled', 'true');
-    await modal(page).getByRole('combobox', { name: 'Tagging model', exact: true }).selectOption('wd14-vit');
-    await expect(status).toHaveText('');
-    await expect(start).not.toHaveAttribute('aria-disabled', 'true');
-    await actionButtons(page).first().click();
-    await expect(modal(page)).toHaveCount(0);
-});
-
 test('Suggestions field prefills from the setting and caps chips at the entered count', async ({ page, request }) => {
     await expect(await request.post('/__test__/tagging/defaults', { data: { general: 0.5, character: 0.9, limit: 7 } })).toBeOK();
     await select(page, FIRST);

tests/browser/workspace-tagging.spec.mjs

@@ -260,18 +260,6 @@ test('unavailable model shows inline status and never downloads', async ({ page,
     await expect(dialog(page).locator('.dialog-actions .ca-primary')).toBeFocused();
 });
 
-test('a missing backend package is the server\'s install sentence, no traceback page (#424)', async ({ page, request }) => {
-    await expect(await request.post('/__test__/tagging/models', { data: { unavailable: [],
-        missing_packages: { 'wd14-swinv2': ['onnxruntime'] } } })).toBeOK();
-    await openTag(page);
-    const answer = await generated(page);
-    expect(answer.status()).toBe(409);
-    expect(await answer.json()).toMatchObject({ success: false, code: 'model-unavailable' });
-    await expect(status(page)).toHaveText('WD14 SwinV2 needs onnxruntime. Install it into ComfyUI\'s Python: '
-        + 'pip install onnxruntime. Use onnxruntime-gpu for CUDA.');
-    await expect(chips(page)).toHaveCount(0);
-});
-
 test('video tag is manual only', async ({ page, request }) => {
     await openTag(page, VIDEO);
     const preview = dialog(page).locator('video.tag-image-preview');

tests/browser/workspace_tagging_fixture.py

@@ -41,18 +41,6 @@ FILES = (
     ("loose/unlinked.png", "unlinked"),
 )
 MODELS = ("wd14-swinv2", "wd14-vit", "gguf", "hf")
-
-
-def _valid_missing(value) -> bool:
-    """``{"<model>": ["<pip name>", ...]}`` with known models and string names."""
-    return isinstance(value, dict) and all(
-        name in MODELS
-        and isinstance(names, list)
-        and all(isinstance(pip, str) and pip for pip in names)
-        for name, names in value.items()
-    )
-
-
 # Unlinked copies enough to virtualize the Images grid (it renders all up to 120).
 MAX_EXTRA_IMAGES = 160
 _TABLES = (
@@ -229,7 +217,6 @@ def register_tagging_commands(
         if not 0 <= extra <= MAX_EXTRA_IMAGES:
             raise web.HTTPBadRequest()
         model.unavailable = set()
-        model.missing_packages = {}
         model.suggestions = None
         model.loaded = None
         restore_download()
@@ -248,25 +235,17 @@ def register_tagging_commands(
 
     @routes.post("/__test__/tagging/models")
     async def models(request: web.Request) -> web.Response:
-        """Mark fake models as not downloaded (``{"unavailable": [...]}``) and,
-        optionally, as missing backend packages (``"missing_packages":
-        {"<model>": ["<pip name>", ...]}``, #424)."""
+        """Mark fake models as not downloaded (``{"unavailable": [...]}``)."""
         data = await request.json() if request.can_read_body else None
         if (
             request.query
             or not isinstance(data, dict)
-            or "unavailable" not in data
-            or set(data) - {"unavailable", "missing_packages"}
+            or set(data) != {"unavailable"}
             or not isinstance(data["unavailable"], list)
             or any(name not in MODELS for name in data["unavailable"])
-            or not _valid_missing(data.get("missing_packages", {}))
         ):
             raise web.HTTPBadRequest()
         model.unavailable = set(data["unavailable"])
-        model.missing_packages = {
-            name: list(names)
-            for name, names in data.get("missing_packages", {}).items()
-        }
         return web.json_response({"success": True})
 
     @routes.post("/__test__/tagging/loaded")

tests/fixtures/legacy_contract_snapshot.json

@@ -1,7 +1,5 @@
 {
   "routes": [
-    "DELETE /prompt_manager/collections/items",
-    "DELETE /prompt_manager/collections/{collection_id}",
     "DELETE /prompt_manager/delete/{prompt_id}",
     "DELETE /prompt_manager/image-annotations/capture/{token}",
     "DELETE /prompt_manager/images/category",
@@ -17,8 +15,6 @@
     "GET /prompt_manager/backup",
     "GET /prompt_manager/backup/status",
     "GET /prompt_manager/categories",
-    "GET /prompt_manager/collections",
-    "GET /prompt_manager/collections/membership",
     "GET /prompt_manager/diagnostics",
     "GET /prompt_manager/export",
     "GET /prompt_manager/gallery",
@@ -96,7 +92,6 @@
     "GET /prompt_manager/vocabulary/tags/{tag_id}/impact",
     "GET /prompt_manager/web",
     "GET /prompt_manager/workspace",
-    "PATCH /prompt_manager/collections/{collection_id}",
     "PATCH /prompt_manager/library/{positive_id}",
     "PATCH /prompt_manager/pairs/{pair_id}",
     "PATCH /prompt_manager/saved-views/{view_id}",
@@ -111,7 +106,6 @@
     "POST /prompt_manager/bulk/delete",
     "POST /prompt_manager/bulk/tags",
     "POST /prompt_manager/cleanup",
-    "POST /prompt_manager/collections/items",
     "POST /prompt_manager/delete_duplicate_images",
     "POST /prompt_manager/diagnostics/test-link",
     "POST /prompt_manager/gallery/rescan",

tests/js/workspace-images-tagging-bulk.test.js

@@ -135,41 +135,6 @@ test('a model that is not downloaded is named with the server sentence', () => {
     assert.throws(() => modelUnavailable({}, 'nope'), TypeError);
 });
 
-test('a downloaded model whose backend package is missing names the package and the command (#424)', () => {
-    const { modelUnavailable, needsPackages } = state;
-    const gguf = { downloaded: true, name: 'GGUF (Recommended)', label: 'GGUF JoyCaption', missing_packages: ['llama-cpp-python'],
-        install_command: 'pip install llama-cpp-python',
-        install_note: 'For a CUDA build: CMAKE_ARGS="-DGGML_CUDA=on" pip install llama-cpp-python' };
-    const sentence = 'GGUF JoyCaption needs llama-cpp-python. Install it into ComfyUI\'s Python: pip install llama-cpp-python. '
-        + 'For a CUDA build: CMAKE_ARGS="-DGGML_CUDA=on" pip install llama-cpp-python';
-    assert.equal(modelUnavailable({ gguf }, 'gguf'), sentence);
-    // Not downloaded is named first, in its own sentence.
-    assert.equal(modelUnavailable({ gguf: { ...gguf, downloaded: false } }, 'gguf'),
-        'GGUF (Recommended) is not downloaded. Download it in System › Auto-tagging.');
-    assert.equal(modelUnavailable({ gguf: { ...gguf, missing_packages: [] } }, 'gguf'), '');
-    assert.equal(needsPackages('HuggingFace JoyCaption', { missing_packages: ['accelerate', 'bitsandbytes'] }),
-        'HuggingFace JoyCaption needs accelerate and bitsandbytes. Install them into ComfyUI\'s Python: pip install accelerate bitsandbytes.');
-    assert.equal(needsPackages('X', { missing_packages: ['a', 'b', 'c'], install_command: 'pip install a b c' }),
-        'X needs a, b and c. Install them into ComfyUI\'s Python: pip install a b c.');
-    assert.equal(needsPackages('X', null), '');
-    assert.equal(needsPackages('X', { missing_packages: [1, ''] }), '');
-    // Without the server's label the option's own name is used.
-    assert.ok(modelUnavailable({ 'wd14-vit': { downloaded: true, missing_packages: ['onnxruntime'] } }, 'wd14-vit')
-        .startsWith('WD14 ViT needs onnxruntime.'));
-});
-
-test('the bulk dialog keeps Start disabled while the chosen model misses a package (#424)', async () => {
-    const { createTaggingOptionsController } = state;
-    const models = { 'wd14-vit': { downloaded: true, label: 'WD14 ViT', missing_packages: ['onnxruntime'],
-        install_command: 'pip install onnxruntime' } };
-    const options = createTaggingOptionsController({ api: { get: async () => ({ success: true, models, model_type: 'wd14-vit' }) } });
-    await options.open();
-    assert.equal(options.state.model, 'wd14-vit');
-    assert.equal(options.state.canStart, false);
-    assert.equal(options.state.unavailable, 'WD14 ViT needs onnxruntime. Install it into ComfyUI\'s Python: pip install onnxruntime.');
-    options.dispose();
-});
-
 test('the bulk options start from the server defaults and wait for them before Start', async () => {
     const { createTaggingOptionsController } = state;
     let answer;

tests/js/workspace-system-backups.test.js

@@ -63,9 +63,9 @@ test('status line shows only server-reported backups (D103)', async () => {
 
 const PREVIEW = Object.freeze({
     success: true, token: 'r'.repeat(43), expires_at: '2026-10-25T12:15:00+00:00',
-    summary: { prompts: 1234, positives: 900, pairs: 3, archived_pairs: 0, image_links: 56, runs: 1, saved_views: 2, collections: 1 },
+    summary: { prompts: 1234, positives: 900, pairs: 3, archived_pairs: 0, image_links: 56, runs: 1, saved_views: 2 },
     schema: { migrated: true, library_state: true }, integrity: 'ok', documents: { repaired: 0, cleared: 0, images: 0 },
-    live: { prompts: 1, positives: 1, pairs: 0, archived_pairs: 0, image_links: 0, runs: 0, saved_views: 0, collections: 0 }, size: 4096,
+    live: { prompts: 1, positives: 1, pairs: 0, archived_pairs: 0, image_links: 0, runs: 0, saved_views: 0 }, size: 4096,
     safety_backup: { destination_label: 'prompts.db.backup_<date and time>' },
 });
 

tests/js/workspace-system-tagging.test.js

@@ -482,60 +482,6 @@ test('Tag output images › Review previews the drafts, else says why; a refused
     } finally { scope.dispose(); dom.restore(); }
 });
 
-// #424: GGUF on disk without llama-cpp-python.
-const NEEDS_LLAMA = { missing_packages: ['llama-cpp-python'], install_command: 'pip install llama-cpp-python',
-    install_note: 'For a CUDA build: CMAKE_ARGS="-DGGML_CUDA=on" pip install llama-cpp-python' };
-const NEEDS_SENTENCE = 'GGUF JoyCaption needs llama-cpp-python. Install it into ComfyUI\'s Python: pip install llama-cpp-python. '
-    + 'For a CUDA build: CMAKE_ARGS="-DGGML_CUDA=on" pip install llama-cpp-python';
-
-test('a model on disk whose backend package is missing never reads as ready (#424)', async () => {
-    const { modelDescription, readStatus, batchCloseNote, STATUS_COPY } = await tagging;
-    const status = readStatus({ ...MODELS, models: { ...MODELS.models,
-        gguf: entry('GGUF JoyCaption', '~4.5 GB', { ...NEEDS_LLAMA }),
-        'wd14-vit': entry('WD14 ViT', '~400 MB', { downloaded: false, missing_packages: ['onnxruntime'],
-            install_command: 'pip install onnxruntime', install_note: 'Use onnxruntime-gpu for CUDA.' }),
-        hf: entry('HuggingFace JoyCaption', '~16 GB', { downloaded: false, model_exists: undefined,
-            missing_packages: ['accelerate', 'bitsandbytes'], install_command: 'pip install accelerate bitsandbytes' }) } });
-    const ready = modelDescription(status, 'gguf');
-    assert.notEqual(ready, STATUS_COPY.downloaded);
-    assert.equal(ready, 'Downloaded. Needs llama-cpp-python: pip install llama-cpp-python. '
-        + 'For a CUDA build: CMAKE_ARGS="-DGGML_CUDA=on" pip install llama-cpp-python');
-    // Not downloaded reads differently, and still says what it will need.
-    assert.equal(modelDescription(status, 'wd14-vit'), 'Not downloaded. Download size ~400 MB. Also needs onnxruntime.');
-    assert.equal(modelDescription(status, 'hf'), 'Not downloaded. Download size ~16 GB. Also needs accelerate and bitsandbytes.');
-    const partial = readStatus({ ...MODELS, models: { ...MODELS.models, gguf: entry('GGUF JoyCaption', '~4.5 GB',
-        { downloaded: false, model_exists: true, mmproj_exists: false, ...NEEDS_LLAMA }) } });
-    assert.equal(modelDescription(partial, 'gguf'), 'Partly downloaded. Download again to finish. Also needs llama-cpp-python.');
-    // Untrusted shapes are ignored; a missing command is built from the names.
-    const odd = readStatus({ ...MODELS, models: { ...MODELS.models, gguf: entry('GGUF JoyCaption', '~4.5 GB',
-        { missing_packages: ['llama-cpp-python', 3, ''], install_command: 7, install_note: {} }) } });
-    assert.equal(modelDescription(odd, 'gguf'), 'Downloaded. Needs llama-cpp-python: pip install llama-cpp-python.');
-    const junk = readStatus({ ...MODELS, models: { ...MODELS.models, gguf: entry('GGUF JoyCaption', '~4.5 GB',
-        { missing_packages: 'llama-cpp-python' }) } });
-    assert.equal(modelDescription(junk, 'gguf'), STATUS_COPY.downloaded);
-    // The batch review says why it cannot start, in the server's sentence.
-    assert.equal(batchCloseNote({ ...PLAN, model: { type: 'gguf', label: 'GGUF JoyCaption', downloaded: true, ...NEEDS_LLAMA } }),
-        NEEDS_SENTENCE);
-    assert.equal(batchCloseNote({ ...PLAN, model: { ...PLAN.model, downloaded: false, ...NEEDS_LLAMA } }),
-        'WD14 SwinV2 is not downloaded. Download it first.');
-});
-
-test('Review explains a missing backend package instead of reviewing (#424)', async () => {
-    const models = { ...MODELS, models: { ...MODELS.models, gguf: entry('GGUF JoyCaption', '~4.5 GB', { ...NEEDS_LLAMA }) } };
-    const { dom, scope, button, byId, calls } = await mounted({ models });
-    try {
-        byId('tag-model').value = 'gguf'; await byId('tag-model').dispatch('change');
-        const review = button('Review');
-        assert.equal(review.getAttribute('aria-disabled'), 'true');
-        assert.equal(review.dataset.reason, NEEDS_SENTENCE);
-        await review.dispatch('click');
-        assert.equal(calls.toasts.at(-1), NEEDS_SENTENCE);
-        assert.deepEqual(calls.post, []);
-        // Download stays offered: files and packages are separate.
-        assert.equal(button('Download again').getAttribute('aria-disabled'), null);
-    } finally { scope.dispose(); dom.restore(); }
-});
-
 test('settingRefusal marks only an Auto-tagging save\'s plain 400 as invalid-setting (CUJ 2a)', async () => {
     const { settingRefusal } = await import('../../web/js/workspace/system.mjs');
     const refusal = (extra = {}) => Object.assign(new Error('General-tag confidence must be between 0 and 1.'),

tests/test_api_annotation_suggest.py

@@ -29,7 +29,6 @@ except ImportError:
     model_gate = None
 
 from py import config as config_module
-from py.autotag import MissingBackendPackages, package_fields
 
 AutotagConfig = getattr(config_module, "AutotagConfig", None)
 
@@ -38,11 +37,6 @@ WAIT = 30.0
 WD14 = {"general_threshold": 0.35, "character_threshold": 0.85}
 LLM = {"instructions": "Generate tags."}
 UNAVAILABLE = "Download it in System › Auto-tagging."
-NEEDS_LLAMA = (
-    "GGUF JoyCaption needs llama-cpp-python. Install it into ComfyUI's Python: "
-    'pip install llama-cpp-python. For a CUDA build: CMAKE_ARGS="-DGGML_CUDA=on" '
-    "pip install llama-cpp-python"
-)
 
 SCORED = [("sandstone", 0.98), ("desert", 0.96)] + [
     (f"tag_{i:03d}", round(0.9 - i * 0.005, 4)) for i in range(150)
@@ -65,8 +59,6 @@ class FakeTagger:
             "hf": {},
         }
         self.downloaded = {name: True for name in self.models_config}
-        # pip names of the backend packages that cannot be imported (#424)
-        self.missing = {name: [] for name in self.models_config}
         self.loaded = None
         self.load_calls = []
         self.unload_calls = 0
@@ -79,11 +71,7 @@ class FakeTagger:
 
     def get_models_status(self):
         return {
-            name: {
-                "downloaded": self.downloaded[name],
-                "model_path": None,
-                **package_fields(name, self.missing[name]),
-            }
+            name: {"downloaded": self.downloaded[name], "model_path": None}
             for name in self.models_config
         }
 
@@ -327,37 +315,6 @@ class TestModelAvailability(SuggestTestCase):
         self.assertEqual(self.tagger.calls, [])
         self.assertIsNone(model_gate.holder())
 
-    async def test_missing_backend_package_is_refused_before_the_model(self):
-        observed = await self.observed()
-        self.tagger.missing["gguf"] = ["llama-cpp-python"]
-
-        status, body = await self.suggest(self.suggest_body(observed, "gguf"))
-
-        self.assertEqual((status, body["code"]), (409, "model-unavailable"))
-        self.assertEqual(body["success"], False)
-        self.assertEqual(body["error"], NEEDS_LLAMA)
-        self.assertEqual(self.tagger.load_calls, [])
-        self.assertIsNone(model_gate.holder())
-        # Not downloaded still reads as before, whatever the packages.
-        self.tagger.downloaded["gguf"] = False
-        status, body = await self.suggest(self.suggest_body(observed, "gguf"))
-        self.assertIn("is not downloaded", body["error"])
-
-    async def test_a_package_lost_after_the_check_is_the_same_409_without_a_traceback(
-        self,
-    ):
-        observed = await self.observed()
-        self.tagger.load_error = MissingBackendPackages("gguf", ["llama-cpp-python"])
-
-        with self.assertNoLogs(self.api.logger, level="ERROR"):
-            status, body = await self.suggest(self.suggest_body(observed, "gguf"))
-
-        self.assertEqual((status, body["code"]), (409, "model-unavailable"))
-        self.assertEqual(body["error"], NEEDS_LLAMA)
-        self.assertIsNone(model_gate.holder())
-        entry = self.api._captures._entries[observed["capture"]["token"]]
-        self.assertEqual(entry.uses, 0)
-
     async def test_load_failure_is_a_generic_error_and_frees_everything(self):
         observed = await self.observed()
         self.tagger.load_error = RuntimeError(f"cannot load {self.output_dir}")

tests/test_api_autotag.py

@@ -73,7 +73,6 @@ class FakeAutotagService:
         self.status_calls = 0
         self.status_threads = []
         self.status_paths = {}
-        self.status_extra = {}
         self.suggest_calls = 0
 
     def get_models_status(self):
@@ -83,7 +82,6 @@ class FakeAutotagService:
             name: {
                 "downloaded": self.downloaded,
                 "model_path": self.status_paths.get(name),
-                **self.status_extra.get(name, {}),
             }
             for name in self.models_config
         }
@@ -1113,24 +1111,6 @@ class TestModelStatus(AutotagAPITestCase):
         leaked = [text for text in _strings(data) if _absolute(text)]
         self.assertEqual(leaked, [])
 
-    async def test_models_status_names_missing_backend_packages(self):
-        fields = {
-            "missing_packages": ["llama-cpp-python"],
-            "install_command": "pip install llama-cpp-python",
-            "install_note": "For a CUDA build: ...",
-        }
-        self.service.status_extra = {"gguf": fields}
-        models = (await self._models())["models"]
-        self.assertTrue(models["gguf"]["downloaded"])
-        self.assertEqual(
-            {key: models["gguf"][key] for key in fields},
-            fields,
-        )
-        self.assertEqual(
-            {key: models["wd14-vit"][key] for key in fields},
-            {"missing_packages": [], "install_command": None, "install_note": None},
-        )
-
     async def test_models_status_adds_label_size_label_and_loaded(self):
         self.service._loaded_type = "wd14-vit"
         data = await self._models()
@@ -1689,10 +1669,6 @@ class TestTagOutputImagesPreview(BatchJobTestCase):
                 "label": "WD14 ViT",
                 "size_label": "~400 MB",
                 "downloaded": True,
-                # #424: the backend packages it cannot import, none here.
-                "missing_packages": [],
-                "install_command": None,
-                "install_note": None,
             },
         )
         self.assertEqual(skip["existing"], "skip")

tests/test_api_collections.py

@@ -1,601 +0,0 @@
-"""Collections (#331): the routes under /prompt_manager/collections."""
-
-import json
-import ntpath
-import sqlite3
-from unittest.mock import patch
-
-try:
-    from test_api_images import ImageAPITestCase, make_png
-    from open_handles import assert_closed
-except ImportError:
-    from tests.test_api_images import ImageAPITestCase, make_png
-    from tests.open_handles import assert_closed
-
-BASE = "/prompt_manager/collections"
-ITEMS = BASE + "/items"
-MEMBERSHIP = BASE + "/membership"
-SOURCES_CHANGED = "The sources changed. Refresh the images and try again."
-
-
-class CollectionRoutesTestCase(ImageAPITestCase):
-    async def tearDownAsync(self):
-        self.api.db.close_all()
-        assert_closed(self, self._temp_db.name, self._output_tmp.name)
-        await super().tearDownAsync()
-
-    def make(self, *names, root=None):
-        for name in names:
-            make_png((root or self.output_dir) / name)
-
-    def scope(self, index=0):
-        roots = list(self.api._get_all_output_dirs())
-        return self.api._gallery_root_scope(roots[index], index)
-
-    def item(self, path, index=0, scope=None):
-        return {
-            "root_index": index,
-            "root_scope": scope or self.scope(index),
-            "path": path,
-        }
-
-    def two_sources(self):
-        second = self.comfy_dir / "second"
-        second.mkdir()
-        self.api._get_all_output_dirs = lambda: [self.output_dir, second]
-        return second
-
-    async def call(self, method, url, body=None, status=200, **params):
-        response = await self.client.request(method, url, json=body, params=params)
-        text = await response.text()
-        self.assertEqual(response.status, status, text)
-        data = json.loads(text)
-        self.assertNotIn(self.comfy_dir.as_posix(), text)
-        self.assertNotIn(str(self.comfy_dir).replace("\\", "\\\\"), text)
-        return data
-
-    async def add(self, status=200, **body):
-        return await self.call("POST", ITEMS, body, status)
-
-    async def listed(self):
-        return (await self.call("GET", BASE))["collections"]
-
-
-class TestCollectionRoutes(CollectionRoutesTestCase):
-    async def test_each_route_succeeds(self):
-        self.make("a.png", "b.png", "c.png")
-        self.assertEqual(
-            await self.call("GET", BASE), {"success": True, "collections": []}
-        )
-        made = await self.add(
-            name="  LoRa   testing ", items=[self.item("a.png"), self.item("b.png")]
-        )
-        grids = made["collection"]
-        self.assertEqual(grids["name"], "LoRa testing")
-        self.assertEqual(
-            made,
-            {
-                "success": True,
-                "collection": grids,
-                "created": True,
-                "added": 2,
-                "already": 0,
-                "not_found": 0,
-            },
-        )
-        again = await self.add(
-            collection_id=grids["id"], items=[self.item("b.png"), self.item("c.png")]
-        )
-        self.assertEqual(
-            (again["created"], again["added"], again["already"]), (False, 1, 1)
-        )
-        self.assertEqual(
-            await self.listed(),
-            [{"id": grids["id"], "name": "LoRa testing", "count": 3, "missing": 0}],
-        )
-        membership = await self.call(
-            "GET", MEMBERSHIP, root_index="0", root_scope=self.scope(), path="a.png"
-        )
-        self.assertEqual(membership, {"success": True, "collection_ids": [grids["id"]]})
-        removed = await self.call(
-            "DELETE",
-            ITEMS,
-            {"collection_id": grids["id"], "items": [self.item("a.png")]},
-        )
-        self.assertEqual(removed, {"success": True, "collection": grids, "removed": 1})
-        renamed = await self.call(
-            "PATCH", f"{BASE}/{grids['id']}", {"name": "LoRA grids"}
-        )
-        self.assertEqual(
-            renamed,
-            {"success": True, "collection": {"id": grids["id"], "name": "LoRA grids"}},
-        )
-        deleted = await self.call("DELETE", f"{BASE}/{grids['id']}")
-        self.assertEqual(deleted, {"success": True, "deleted": True})
-        self.assertEqual(await self.listed(), [])
-        # Files are never touched.
-        self.assertTrue((self.output_dir / "a.png").is_file())
-
-    async def test_names_are_unique_ignoring_case(self):
-        self.make("a.png", "b.png")
-        first = (await self.add(name="LoRa testing", items=[self.item("a.png")]))[
-            "collection"
-        ]
-        second = await self.add(name="lora TESTING", items=[self.item("b.png")])
-        self.assertEqual(second["collection"], first)
-        self.assertFalse(second["created"])
-        self.assertEqual(len(await self.listed()), 1)
-
-    async def test_bad_requests_are_400(self):
-        self.make("a.png")
-        made = await self.add(name="Set", items=[self.item("a.png")])
-        cid = made["collection"]["id"]
-        good = [self.item("a.png")]
-        for body in (
-            {"items": good},
-            {"name": "x", "collection_id": cid, "items": good},
-            {"name": "x"},
-            {"name": "x", "items": good, "extra": 1},
-            {"collection_id": "1", "items": good},
-            {"collection_id": True, "items": good},
-            {"collection_id": 0, "items": good},
-            {"collection_id": 10**10, "items": good},
-            {"name": "", "items": good},
-            {"name": "x" * 101, "items": good},
-            {"name": "bell\x07", "items": good},
-            {"name": 5, "items": good},
-            {"name": "x", "items": []},
-            {"name": "x", "items": "a.png"},
-            {"name": "x", "items": [self.item("a.png")] * 501},
-            {"name": "x", "items": [{"root_index": 0, "path": "a.png"}]},
-            {"name": "x", "items": [{**self.item("a.png"), "root_index": "0"}]},
-            {"name": "x", "items": [{**self.item("a.png"), "root_scope": "xyz"}]},
-        ):
-            with self.subTest(body=body):
-                data = await self.add(400, **body)
-                self.assertFalse(data["success"])
-        for body in ({"items": good}, {"collection_id": cid}):
-            with self.subTest(remove=body):
-                await self.call("DELETE", ITEMS, body, 400)
-        for raw in ("abc", "0", "1234567890", "-1", "1.0"):
-            with self.subTest(path_id=raw):
-                await self.call("PATCH", f"{BASE}/{raw}", {"name": "x"}, 400)
-                await self.call("DELETE", f"{BASE}/{raw}", None, 400)
-        await self.call("PATCH", f"{BASE}/{cid}", {"name": ""}, 400)
-        await self.call("PATCH", f"{BASE}/{cid}", {"label": "x"}, 400)
-        for params in (
-            {"root_index": "x", "root_scope": self.scope(), "path": "a.png"},
-            {"root_index": "0", "path": "a.png"},
-            {"root_index": "0", "root_scope": "nope", "path": "a.png"},
-        ):
-            with self.subTest(membership=params):
-                await self.call("GET", MEMBERSHIP, status=400, **params)
-        self.assertEqual((await self.listed())[0]["count"], 1)
-
-    async def test_unsafe_paths_are_403(self):
-        self.make("a.png")
-        for path in (
-            "../a.png",
-            "sub/../../a.png",
-            "C:/a.png",
-            "a\\b.png",
-            "/a.png",
-            "notes.txt",
-        ):
-            with self.subTest(path=path):
-                await self.add(403, name="Set", items=[self.item(path)])
-                await self.call(
-                    "GET",
-                    MEMBERSHIP,
-                    status=403,
-                    root_index="0",
-                    root_scope=self.scope(),
-                    path=path,
-                )
-        self.assertEqual(await self.listed(), [])
-
-    async def test_a_body_over_the_cap_is_413(self):
-        response = await self.client.post(
-            ITEMS, data=b'{"name":"x","items":[' + b" " * (1024 * 1024 + 1) + b"]}"
-        )
-        self.assertEqual(response.status, 413)
-
-    async def test_missing_collection_and_files_are_404(self):
-        self.make("a.png")
-        data = await self.add(404, collection_id=999, items=[self.item("a.png")])
-        self.assertEqual(data["code"], "collection-not-found")
-        data = await self.call(
-            "DELETE", ITEMS, {"collection_id": 999, "items": [self.item("a.png")]}, 404
-        )
-        self.assertEqual(data["code"], "collection-not-found")
-        data = await self.call("PATCH", f"{BASE}/999", {"name": "x"}, 404)
-        self.assertEqual(data["code"], "collection-not-found")
-        data = await self.call("DELETE", f"{BASE}/999", None, 404)
-        self.assertEqual(data["code"], "collection-not-found")
-        data = await self.add(404, name="New", items=[self.item("never.png")])
-        self.assertEqual(data["code"], "files-not-found")
-        self.assertEqual(await self.listed(), [])
-
-    async def test_unlisted_files_count_as_not_found(self):
-        self.make("a.png")
-        made = await self.add(
-            name="Set", items=[self.item("a.png"), self.item("later.png")]
-        )
-        self.assertEqual((made["added"], made["not_found"]), (1, 1))
-        again = await self.add(
-            collection_id=made["collection"]["id"],
-            items=[self.item("a.png"), self.item("later.png")],
-        )
-        self.assertEqual(
-            (again["added"], again["already"], again["not_found"]), (0, 1, 1)
-        )
-
-    async def test_name_taken_is_409(self):
-        self.make("a.png")
-        first = (await self.add(name="First", items=[self.item("a.png")]))["collection"]
-        second = (await self.add(name="Second", items=[self.item("a.png")]))[
-            "collection"
-        ]
-        data = await self.call(
-            "PATCH", f"{BASE}/{second['id']}", {"name": "FIRST"}, 409
-        )
-        self.assertEqual(
-            (data["code"], data["collection_id"]), ("name-taken", first["id"])
-        )
-        renamed = await self.call("PATCH", f"{BASE}/{second['id']}", {"name": "SECOND"})
-        self.assertEqual(renamed["collection"]["name"], "SECOND")
-
-    async def test_stale_scope_is_409_after_reordering_sources(self):
-        second = self.two_sources()
-        self.make("a.png")
-        self.make("b.png", root=second)
-        stale = self.item("b.png", 1)
-        made = await self.add(name="Set", items=[self.item("a.png")])
-        cid = made["collection"]["id"]
-        self.api._get_all_output_dirs = lambda: [second, self.output_dir]
-        for method, body in (
-            ("POST", {"collection_id": cid, "items": [self.item("b.png", 0), stale]}),
-            ("DELETE", {"collection_id": cid, "items": [stale]}),
-        ):
-            with self.subTest(method=method):
-                data = await self.call(method, ITEMS, body, 409)
-                self.assertEqual(data["code"], "source-changed")
-                self.assertEqual(data["error"], SOURCES_CHANGED)
-        data = await self.call(
-            "GET",
-            MEMBERSHIP,
-            status=409,
-            root_index="1",
-            root_scope=stale["root_scope"],
-            path="b.png",
-        )
-        self.assertEqual(data["code"], "source-changed")
-        # Nothing was written by the refused add; the member follows its folder.
-        listed = await self.listed()
-        self.assertEqual((listed[0]["count"], listed[0]["missing"]), (1, 0))
-        membership = await self.call(
-            "GET", MEMBERSHIP, root_index="1", root_scope=self.scope(1), path="a.png"
-        )
-        self.assertEqual(membership["collection_ids"], [cid])
-
-    async def test_counts_exclude_a_missing_member(self):
-        second = self.two_sources()
-        self.make("a.png", "b.png")
-        self.make("c.png", root=second)
-        made = await self.add(
-            name="Grids",
-            items=[self.item("a.png"), self.item("b.png"), self.item("c.png", 1)],
-        )
-        other = await self.add(name="Other", items=[self.item("c.png", 1)])
-        (self.output_dir / "b.png").unlink()
-        self.api.invalidate_gallery_cache()
-        listed = await self.listed()
-        self.assertEqual(
-            listed,
-            [
-                {
-                    "id": made["collection"]["id"],
-                    "name": "Grids",
-                    "count": 2,
-                    "missing": 1,
-                },
-                {
-                    "id": other["collection"]["id"],
-                    "name": "Other",
-                    "count": 1,
-                    "missing": 0,
-                },
-            ],
-        )
-        # The member is removable although it is no longer listed.
-        removed = await self.call(
-            "DELETE",
-            ITEMS,
-            {"collection_id": made["collection"]["id"], "items": [self.item("b.png")]},
-        )
-        self.assertEqual(removed["removed"], 1)
-
-    async def test_counts_are_null_when_a_source_scan_fails(self):
-        self.make("a.png")
-        await self.add(name="Set", items=[self.item("a.png")])
-
-        async def broken(_root):
-            raise OSError("scan failed at /secret/place")
-
-        with patch.object(self.api, "_get_gallery_files", side_effect=broken):
-            data = await self.call("GET", BASE)
-        self.assertEqual(
-            data["collections"][0] | {"id": 0},
-            {"id": 0, "name": "Set", "count": None, "missing": None},
-        )
-        self.assertNotIn("secret", json.dumps(data))
-
-    async def test_windows_case_spellings_are_one_member(self):
-        self.make("Sub/A.png")
-        with patch("py.api.images._path_flavor", ntpath):
-            made = await self.add(
-                name="Set", items=[self.item("Sub/A.png"), self.item("SUB/a.PNG")]
-            )
-            self.assertEqual((made["added"], made["already"]), (1, 0))
-            (self.output_dir / "Sub" / "A.png").rename(
-                self.output_dir / "Sub" / "a.png"
-            )
-            (self.output_dir / "Sub").rename(self.output_dir / "sub")
-            self.api.invalidate_gallery_cache()
-            listed = await self.listed()
-            self.assertEqual((listed[0]["count"], listed[0]["missing"]), (1, 0))
-            membership = await self.call(
-                "GET",
-                MEMBERSHIP,
-                root_index="0",
-                root_scope=self.scope(),
-                path="sub/a.png",
-            )
-            self.assertEqual(membership["collection_ids"], [made["collection"]["id"]])
-            response = await self.client.get(
-                "/prompt_manager/images/output",
-                params={
-                    "mode": "workspace",
-                    "collection": str(made["collection"]["id"]),
-                },
-            )
-            page = await response.json()
-            self.assertEqual([i["path"] for i in page["images"]], ["sub/a.png"])
-
-    async def test_posix_case_distinct_files_stay_two_members(self):
-        self.make("A.png", "a.png")
-        if len(list(self.output_dir.iterdir())) != 2:
-            self.skipTest("case-insensitive filesystem")
-        made = await self.add(
-            name="Set", items=[self.item("A.png"), self.item("a.png")]
-        )
-        self.assertEqual(made["added"], 2)
-
-    async def test_a_500_never_carries_the_exception_text(self):
-        self.make("a.png")
-        made = await self.add(name="Set", items=[self.item("a.png")])
-        cid = made["collection"]["id"]
-
-        def broken(*_args, **_kwargs):
-            raise sqlite3.OperationalError("disk I/O error at /secret/prompts.db")
-
-        cases = (
-            (
-                "list_collections",
-                "GET",
-                BASE,
-                None,
-                {},
-                "Collections could not be read.",
-            ),
-            (
-                "file_collections",
-                "GET",
-                MEMBERSHIP,
-                None,
-                {"root_index": "0", "root_scope": self.scope(), "path": "a.png"},
-                "Collections could not be read.",
-            ),
-            (
-                "add_to_collection",
-                "POST",
-                ITEMS,
-                {"collection_id": cid, "items": [self.item("a.png")]},
-                {},
-                "The collection could not be changed.",
-            ),
-            (
-                "remove_from_collection",
-                "DELETE",
-                ITEMS,
-                {"collection_id": cid, "items": [self.item("a.png")]},
-                {},
-                "The collection could not be changed.",
-            ),
-            (
-                "rename_collection",
-                "PATCH",
-                f"{BASE}/{cid}",
-                {"name": "x"},
-                {},
-                "The collection could not be changed.",
-            ),
-            (
-                "delete_collection",
-                "DELETE",
-                f"{BASE}/{cid}",
-                None,
-                {},
-                "The collection could not be changed.",
-            ),
-        )
-        for method_name, method, url, body, params, message in cases:
-            with self.subTest(method=method_name):
-                with patch.object(self.api.db, method_name, side_effect=broken):
-                    data = await self.call(method, url, body, 500, **params)
-                self.assertEqual(data, {"success": False, "error": message})
-
-
-class TestCollectionListingFilter(CollectionRoutesTestCase):
-    """#392's "all N matching" filter carries ``collection`` like the listing."""
-
-    async def test_a_filter_with_a_collection_resolves_only_members(self):
-        second = self.two_sources()
-        self.make("a.png", "b.png")
-        self.make("c.png", root=second)
-        made = await self.add(
-            name="Set", items=[self.item("a.png"), self.item("c.png", 1)]
-        )
-        cid = str(made["collection"]["id"])
-        selection = await self.api.resolve_listing_filter({"collection": cid})
-        self.assertEqual(
-            sorted((index, path) for index, _scope, path in selection.targets),
-            [(0, "a.png"), (1, "c.png")],
-        )
-        selection = await self.api.resolve_listing_filter(
-            {"collection": cid, "root": "1", "root_scope": self.scope(1)}
-        )
-        self.assertEqual([t[2] for t in selection.targets], ["c.png"])
-        for bad in ("0", "x", "1234567890"):
-            with self.subTest(bad=bad):
-                with self.assertRaises(ValueError):
-                    from py.api.images import parse_listing_filter
-
-                    parse_listing_filter({"collection": bad})
-
-    async def test_bulk_category_acts_on_collection_members_only(self):
-        self.make("a.png", "b.png")
-        inside = self._save_prompt("Inside", category="Old")
-        outside = self._save_prompt("Outside", category="Old")
-        self.api.db.link_image_to_prompt(inside, str(self.output_dir / "a.png"))
-        self.api.db.link_image_to_prompt(outside, str(self.output_dir / "b.png"))
-        made = await self.add(name="Set", items=[self.item("a.png")])
-        cid = str(made["collection"]["id"])
-        data = await self.call(
-            "POST",
-            "/prompt_manager/bulk/category",
-            {"images_filter": {"collection": cid}, "category": "New"},
-        )
-        self.assertEqual((data["updated_count"], data["prompt_count"]), (1, 1))
-        self.assertEqual(self.api.db.get_prompt_by_id(inside)["category"], "New")
-        self.assertEqual(self.api.db.get_prompt_by_id(outside)["category"], "Old")
-
-    async def test_a_deleted_collection_in_a_bulk_filter_is_a_404(self):
-        self.make("a.png")
-        data = await self.call(
-            "POST",
-            "/prompt_manager/bulk/category",
-            {"images_filter": {"collection": "77"}, "category": "New"},
-            status=404,
-        )
-        self.assertEqual(data["code"], "collection-not-found")
-        with self.assertRaises(Exception) as caught:
-            await self.api.resolve_listing_filter({"collection": "77"})
-        self.assertEqual(type(caught.exception).__name__, "CollectionMissing")
-
-
-class TestReviewFindings(CollectionRoutesTestCase):
-    """PR #400 review: loop work, counts snapshot, id and query rules."""
-
-    async def test_no_realpath_runs_on_the_event_loop(self):
-        import os
-        import threading
-
-        names = [f"img{n}.png" for n in range(20)]
-        self.make(*names)
-        await self.call("GET", BASE)  # warm the listing cache
-        loop_thread = threading.current_thread()
-        on_loop = []
-        real = os.path.realpath
-
-        def watched(*args, **kwargs):
-            if threading.current_thread() is loop_thread:
-                on_loop.append(args[0])
-            return real(*args, **kwargs)
-
-        items = [self.item(name) for name in names]
-        cid = None
-        with patch("os.path.realpath", side_effect=watched):
-            made = await self.add(name="Set", items=items)
-            cid = made["collection"]["id"]
-            await self.call("DELETE", ITEMS, {"collection_id": cid, "items": items[:5]})
-            await self.call(
-                "GET",
-                MEMBERSHIP,
-                root_index="0",
-                root_scope=items[0]["root_scope"],
-                path="img9.png",
-            )
-            await self.call("GET", BASE)
-        self.assertEqual(on_loop, [])
-
-    async def test_missing_is_never_negative(self):
-        self.make("a.png", "b.png")
-        made = await self.add(
-            name="Set", items=[self.item("a.png"), self.item("b.png")]
-        )
-        cid = made["collection"]["id"]
-        real = self.api.db.collection_count_snapshot
-
-        def raced(root_keys):
-            members, stored = real(root_keys)
-            return members, {cid: 1}  # a remove landed between two reads
-
-        with patch.object(self.api.db, "collection_count_snapshot", side_effect=raced):
-            listed = await self.listed()
-        self.assertEqual((listed[0]["count"], listed[0]["missing"]), (2, 0))
-
-    async def test_path_ids_follow_the_listing_rule(self):
-        self.make("a.png")
-        made = await self.add(name="Set", items=[self.item("a.png")])
-        cid = made["collection"]["id"]
-        for raw in ("0", "007", f"0{cid}"):
-            with self.subTest(raw=raw):
-                await self.call("PATCH", f"{BASE}/{raw}", {"name": "x"}, 400)
-                await self.call("DELETE", f"{BASE}/{raw}", None, 400)
-        self.assertEqual(len(await self.listed()), 1)
-
-    async def test_membership_refuses_repeated_query_keys(self):
-        self.make("a.png", "b.png")
-        response = await self.client.get(
-            MEMBERSHIP
-            + f"?root_index=0&root_scope={self.scope()}&path=a.png&path=b.png"
-        )
-        self.assertEqual(response.status, 400)
-        response = await self.client.get(
-            MEMBERSHIP
-            + f"?root_index=0&root_index=0&root_scope={self.scope()}&path=a.png"
-        )
-        self.assertEqual(response.status, 400)
-
-    async def test_deleting_a_collection_leaves_everything_else(self):
-        from py.api.images import _favorite_root_key
-
-        try:
-            from tests.test_annotation_schema import insert_group_rows, table_rows
-        except ImportError:
-            from test_annotation_schema import insert_group_rows, table_rows
-
-        self.make("a.png")
-        db = self.api.db
-        db.set_image_favorite(_favorite_root_key(self.output_dir), "a.png")
-        prompt = self._save_prompt("Linked")
-        db.link_image_to_prompt(prompt, str(self.output_dir / "a.png"))
-        with db.model.get_connection() as conn:
-            insert_group_rows(conn, locator=str(self.output_dir / "a.png"))
-        made = await self.add(name="Set", items=[self.item("a.png")])
-        tables = (
-            "image_favorites",
-            "generated_images",
-            "prompts",
-            "tags",
-            "media_annotation_files",
-            "media_annotation_bytes",
-            "media_image_tags",
-        )
-        before = table_rows(db.model.get_connection(), tables)
-        file_bytes = (self.output_dir / "a.png").read_bytes()
-        await self.call("DELETE", f"{BASE}/{made['collection']['id']}")
-        self.assertEqual(table_rows(db.model.get_connection(), tables), before)
-        self.assertEqual((self.output_dir / "a.png").read_bytes(), file_bytes)
-        self.assertTrue(all(before[t] for t in tables))

tests/test_api_duplicate_files.py

@@ -693,39 +693,6 @@ class TestCleanupJob(DuplicateFilesTestCase):
             "Moved 2 database links to the kept copies", "\n".join(cleanup.log)
         )
 
-    async def test_duplicate_removal_moves_collection_memberships(self):
-        self.trio()
-        db = self.api.db
-        root_key = duplicate_files.favorite_root_key(self.output_dir)
-        grids = db.add_to_collection(name="LoRA grids", items=[(root_key, "b.png")])
-        grids = grids["collection"]["id"]
-        other = db.add_to_collection(
-            name="Other", items=[(root_key, "sub/c.png"), (root_key, "d.png")]
-        )["collection"]["id"]
-        db.add_to_collection(collection_id=grids, items=[(root_key, "sub/c.png")])
-        _plan, cleanup = await self.remove_all_but("a.png")
-        # The union: a.png joins both; c.png's second grids row was a repeat.
-        self.assertEqual(db.collection_members(grids, root_key), {"a.png"})
-        self.assertEqual(db.collection_members(other, root_key), {"a.png", "d.png"})
-        self.assertEqual(sorted(db.file_collections(root_key, "a.png")), [grids, other])
-        self.assertEqual(db.file_collections(root_key, "b.png"), [])
-        self.assertEqual(db.file_collections(root_key, "sub/c.png"), [])
-        self.assertIn(
-            "Moved 2 collection memberships to the kept copies", "\n".join(cleanup.log)
-        )
-
-    def test_one_collection_membership_is_singular(self):
-        job = type(
-            "Job", (), {"log": [], "log_line": lambda s, line: s.log.append(line)}
-        )()
-        totals = dict.fromkeys(
-            ("moved", "merged", "favorites", "tags", "review", "collections"), 0
-        )
-        duplicate_files.DuplicateFilesMixin._log_moved_records(
-            job, {**totals, "collections": 1}
-        )
-        self.assertEqual(job.log, ["Moved 1 collection membership to the kept copies"])
-
     async def test_a_failed_removal_leaves_its_links_on_the_kept_copy(self):
         self.trio()
         prompt = self.save("Stays on c")
@@ -882,11 +849,8 @@ class TestLinkQueries(DuplicateFilesTestCase):
                 with self.subTest(sql=sql):
                     self.assertNotIn("SCAN generated_images", plan)
                     self.assertNotIn("SCAN image_favorites", plan)
-                    self.assertNotIn("SCAN image_collection_items", plan)
         finally:
             conn.close()
-        statements = duplicate_files.query_plan_sql()
-        self.assertTrue(any("image_collection_items" in sql for sql in statements))
 
 
 class TestReviewHelpers(DuplicateFilesTestCase):

tests/test_api_workspace_images.py

@@ -2550,207 +2550,3 @@ class TestListingFilterSelection(ImageAPITestCase):
 
         self.assertEqual(response.status, 409)
         self.assertEqual((await response.json())["code"], "source-changed")
-
-
-class TestWorkspaceCollectionFilter(ImageAPITestCase):
-    """#331: ``collection=<id>`` keeps only that collection's listed members."""
-
-    media = TestWorkspaceImages.media
-    get = TestWorkspaceImages.get
-    _names = TestWorkspaceImages._names
-
-    async def tearDownAsync(self):
-        self.api.db.close_all()
-        assert_closed(self, self._temp_db.name, self._output_tmp.name)
-        await super().tearDownAsync()
-
-    def keys(self, root, relative):
-        from py.api.images import _favorite_relative_key, _favorite_root_key
-
-        return (_favorite_root_key(root), _favorite_relative_key(relative))
-
-    def collect(self, name, *members):
-        """A collection holding ``(root, relative)`` members; its id."""
-        result = self.api.db.add_to_collection(
-            name=name, items=[self.keys(root, rel) for root, rel in members]
-        )
-        return result["collection"]["id"]
-
-    def two_sources(self):
-        second = self.comfy_dir / "second"
-        second.mkdir()
-        self.api._get_all_output_dirs = lambda: [self.output_dir, second]
-        return second
-
-    async def test_listing_keeps_only_collection_members(self):
-        second = self.two_sources()
-        self.media("a.png", 300)
-        self.media("b.png", 200)
-        self.media("sub/c.png", 100, root=second)
-        self.media("d.png", 50, root=second)
-        grids = self.collect(
-            "Grids",
-            (self.output_dir, "a.png"),
-            (second, "sub/c.png"),
-            (self.output_dir, "gone.png"),  # stored, never listed
-        )
-        self.collect("Other", (self.output_dir, "b.png"))
-        response, data = await self.get(collection=str(grids))
-        self.assertEqual(response.status, 200, data)
-        self.assertEqual(self._names(data), ["a.png", "c.png"])
-        self.assertEqual(data["total"], 2)
-        _, data = await self.get(collection=str(grids), root="1")
-        self.assertEqual(self._names(data), ["c.png"])
-        # Without the filter the listing is unchanged.
-        _, data = await self.get()
-        self.assertEqual(data["total"], 4)
-
-    async def test_collection_filter_combines_with_the_other_filters(self):
-        night = self._save_prompt("Neon zebra", category="Night", tags=["a"])
-        day = self._save_prompt("Morning field", category="Day", tags=["a"])
-        files = {
-            name: self.media(name, 100 + index)
-            for index, name in enumerate(
-                ("night.png", "day.png", "zebra_plain.png", "clip.mp4", "out.png")
-            )
-        }
-        self.api.db.link_image_to_prompt(night, str(files["night.png"]))
-        self.api.db.link_image_to_prompt(day, str(files["day.png"]))
-        members = [(self.output_dir, name) for name in files if name != "out.png"]
-        grids = str(self.collect("Grids", *members))
-        cases = (
-            ({}, ["clip.mp4", "day.png", "night.png", "zebra_plain.png"]),
-            ({"q": "zebra"}, ["night.png", "zebra_plain.png"]),
-            ({"category": "Night"}, ["night.png"]),
-            ({"tags": "a"}, ["day.png", "night.png"]),
-            ({"media": "video"}, ["clip.mp4"]),
-            ({"media": "image", "q": "day"}, ["day.png"]),
-        )
-        for params, expected in cases:
-            with self.subTest(**params):
-                response, data = await self.get(collection=grids, sort="name", **params)
-                self.assertEqual(response.status, 200, data)
-                self.assertEqual(self._names(data), expected)
-                self.assertEqual(data["total"], len(expected))
-
-    async def test_collection_filter_combines_with_an_images_own_category(self):
-        """#331 with #332: a member is admitted by its effective category."""
-        from py.api.images import image_category_key
-
-        night = self._save_prompt("Neon zebra", category="Night")
-        files = {
-            name: self.media(name, 100 + index)
-            for index, name in enumerate(
-                ("linked.png", "overridden.png", "own.png", "outside.png")
-            )
-        }
-        for name in ("linked.png", "overridden.png"):
-            self.api.db.link_image_to_prompt(night, str(files[name]))
-        sources = self.api._get_all_output_dirs()
-
-        def own(name, value):
-            key = image_category_key(sources, files[name])
-            self.api.db.set_image_categories([key], value)
-
-        own("overridden.png", "Portraits")
-        own("own.png", "Night")  # unlinked: only its own category
-        own("outside.png", "Night")  # not a member
-        members = [(self.output_dir, name) for name in files if name != "outside.png"]
-        grids = str(self.collect("Grids", *members))
-        for category, expected in (
-            ("Night", ["linked.png", "own.png"]),
-            ("Portraits", ["overridden.png"]),
-        ):
-            with self.subTest(category=category):
-                response, data = await self.get(
-                    collection=grids, category=category, sort="name"
-                )
-                self.assertEqual(response.status, 200, data)
-                self.assertEqual(self._names(data), expected)
-                self.assertEqual(data["total"], len(expected))
-
-    async def test_invalid_collection_is_a_400(self):
-        for value in ("x", "0", "-1", "1.5", "1234567890", " 1"):
-            with self.subTest(value=value):
-                response, data = await self.get(collection=value)
-                self.assertEqual(response.status, 400, data)
-
-    async def test_unknown_collection_is_a_404(self):
-        self.media("a.png")
-        response, data = await self.get(collection="77")
-        self.assertEqual(response.status, 404)
-        self.assertEqual(data["code"], "collection-not-found")
-        self.assertNotIn("images", data)
-        self.api._get_all_output_dirs = lambda: []
-        response, data = await self.get(collection="77")
-        self.assertEqual((response.status, data["code"]), (404, "collection-not-found"))
-
-    async def test_a_collection_deleted_during_the_read_is_a_404(self):
-        self.media("a.png")
-        grids = self.collect("Grids", (self.output_dir, "a.png"))
-        real = self.api.db.collection_members
-
-        def deleted_meanwhile(collection_id, root_key):
-            self.api.db.delete_collection(collection_id)
-            return real(collection_id, root_key)
-
-        with patch.object(
-            self.api.db, "collection_members", side_effect=deleted_meanwhile
-        ):
-            response, data = await self.get(collection=str(grids))
-        self.assertEqual((response.status, data["code"]), (404, "collection-not-found"))
-
-    async def test_a_failed_members_read_is_a_500_never_an_unfiltered_page(self):
-        self.media("a.png")
-        self.media("b.png")
-        grids = self.collect("Grids", (self.output_dir, "a.png"))
-
-        def broken(*_args, **_kwargs):
-            raise sqlite3.OperationalError("database is locked")
-
-        with patch.object(self.api.db, "collection_members", side_effect=broken):
-            response, data = await self.get(collection=str(grids))
-        self.assertEqual(response.status, 500)
-        self.assertNotIn("images", data)
-        self.assertNotIn("locked", json.dumps(data))
-
-    async def test_reordering_sources_keeps_members(self):
-        second = self.two_sources()
-        self.media("a.png", root=second)
-        self.media("b.png")
-        grids = str(self.collect("Grids", (second, "a.png")))
-        _, data = await self.get(collection=grids)
-        self.assertEqual(
-            [(i["root_index"], i["path"]) for i in data["images"]], [(1, "a.png")]
-        )
-        self.api._get_all_output_dirs = lambda: [second, self.output_dir]
-        _, data = await self.get(collection=grids)
-        self.assertEqual(
-            [(i["root_index"], i["path"]) for i in data["images"]], [(0, "a.png")]
-        )
-
-    async def test_cursor_from_another_collection_is_refused(self):
-        for index, name in enumerate(("a.png", "b.png", "c.png")):
-            self.media(name, 100 + index)
-        everything = [(self.output_dir, name) for name in ("a.png", "b.png", "c.png")]
-        first = str(self.collect("First", *everything))
-        second = str(self.collect("Second", *everything))
-        _, page = await self.get(collection=first, limit=1)
-        token = page["next_cursor"]
-        self.assertIsInstance(token, str)
-        response, _ = await self.get(collection=first, limit=1, cursor=token)
-        self.assertEqual(response.status, 200)
-        for params in ({"collection": second}, {}, {"favorites": "1"}):
-            with self.subTest(**params):
-                response, _ = await self.get(cursor=token, limit=1, **params)
-                self.assertEqual(response.status, 400)
-
-    async def test_collection_wins_over_favorites(self):
-        self.media("a.png")
-        self.media("b.png")
-        grids = str(self.collect("Grids", (self.output_dir, "a.png")))
-        from py.api.images import _favorite_root_key
-
-        self.api.db.set_image_favorite(_favorite_root_key(self.output_dir), "b.png")
-        _, data = await self.get(collection=grids, favorites="1")
-        self.assertEqual(self._names(data), ["a.png"])

tests/test_autotag_batch.py

@@ -553,35 +553,6 @@ class TestStartRefusals(BatchTestCase):
         self.assertEqual(self.api._jobs.list(), [])
         self.assertIsNone(model_gate.holder())
 
-    async def test_a_missing_backend_package_refuses_the_start(self):
-        self.tagger.missing["gguf"] = ["llama-cpp-python"]
-        status, data = await self.start_batch(model_type="gguf")
-        self.assertEqual((status, data["code"]), (409, "model-unavailable"))
-        self.assertEqual(data["success"], False)
-        self.assertTrue(
-            data["error"].startswith("GGUF JoyCaption needs llama-cpp-python."), data
-        )
-        self.assertIn("pip install llama-cpp-python", data["error"])
-        self.assertEqual(self.api._jobs.list(), [])
-        self.assertEqual(self.tagger.load_calls, [])
-        self.assertIsNone(model_gate.holder())
-
-    async def test_a_package_lost_after_the_start_fails_the_job_without_a_traceback(
-        self,
-    ):
-        from py.autotag import MissingBackendPackages
-
-        self.image("a.png", (1, 1, 1))
-        self.tagger.load_error = MissingBackendPackages("gguf", ["llama-cpp-python"])
-        with self.assertNoLogs(self.api.logger, level="ERROR"):
-            job = await self.run_batch(model_type="gguf")
-        self.assertEqual(job.state, "failed")
-        self.assertTrue(
-            job.status_line.startswith("GGUF JoyCaption needs"), job.status_line
-        )
-        self.assertTrue(any("pip install llama-cpp-python" in line for line in job.log))
-        self.assertIsNone(model_gate.holder())
-
     async def test_model_busy_when_the_gate_is_held(self):
         owner = model_gate.new_owner("image-annotations")
         self.assertTrue(model_gate.try_acquire(owner))
@@ -687,20 +658,6 @@ class TestPreview(BatchTestCase):
             self.assertIsNone(llm["estimate_device"])
         self.assertEqual([s for s in _strings(skip) if _absolute(s)], [])
 
-    async def test_preview_names_missing_backend_packages(self):
-        self.image("a.png", (1, 1, 1))
-        data = (await self.preview(model_type="gguf"))[1]
-        self.assertEqual(data["model"]["missing_packages"], [])
-        self.assertIsNone(data["model"]["install_command"])
-        self.tagger.missing["gguf"] = ["llama-cpp-python"]
-        data = (await self.preview(model_type="gguf"))[1]
-        self.assertTrue(data["model"]["downloaded"])
-        self.assertEqual(data["model"]["missing_packages"], ["llama-cpp-python"])
-        self.assertEqual(
-            data["model"]["install_command"], "pip install llama-cpp-python"
-        )
-        self.assertIn("DGGML_CUDA", data["model"]["install_note"])
-
     async def test_preview_uses_the_graphics_card_rate_when_wd14_runs_on_cuda(self):
         self.image("a.png", (1, 1, 1))
         self.tagger.wd14_device = lambda: "gpu"

tests/test_autotag_engine.py

@@ -800,12 +800,8 @@ class TestDefaultLoaders(EngineTestCase):
         transformers, model, processor, inputs = self._fake_transformers()
         pixel = inputs["pixel_values"]
         service = AutoTagService(models_dir=self.models_dir)
-        # The 8-bit load also needs these two (#424); stand-ins satisfy the check.
-        stubs = {
-            name: types.ModuleType(name) for name in ("accelerate", "bitsandbytes")
-        }
 
-        with _patch_modules({"torch": torch, "transformers": transformers, **stubs}):
+        with _patch_modules({"torch": torch, "transformers": transformers}):
             service.load_model("hf")
             tags = service.generate_tags(str(self.image_path))
 

tests/test_autotag_legacy.py

@@ -161,39 +161,6 @@ class TestLegacyBatch(LegacyTestCase):
         self.assertEqual(self.tagger.calls[-1]["prompt"], AutotagConfig.TEMPLATE)
         self.assertEqual(self.tagger.custom_prompt, "legacy prompt")
 
-    async def test_a_missing_backend_package_is_one_error_frame(self):
-        self.tagger.missing["gguf"] = ["llama-cpp-python"]
-        _, frames = await self.legacy("model_type=gguf")
-        self.assertEqual(len(frames), 1)
-        self.assertEqual(frames[0]["type"], "error")
-        self.assertTrue(
-            frames[0]["message"].startswith("GGUF JoyCaption needs llama-cpp-python.")
-        )
-        self.assertEqual(self.tagger.load_calls, [])
-
-    async def test_legacy_single_refuses_a_missing_backend_package(self):
-        from py.autotag import MissingBackendPackages
-
-        self.image("a.png", (1, 1, 1))
-        await self.relist()
-        self.tagger.missing["gguf"] = ["llama-cpp-python"]
-        status, data = await self.single(
-            {"path": "a.png", "root_index": 0, "model_type": "gguf"}
-        )
-        self.assertEqual((status, data["code"]), (409, "model-unavailable"))
-        self.assertIn("pip install llama-cpp-python", data["error"])
-        self.assertEqual(self.tagger.load_calls, [])
-        # Lost after the check: the same 409, no ERROR record, nothing held.
-        self.tagger.missing["gguf"] = []
-        self.tagger.load_error = MissingBackendPackages("gguf", ["llama-cpp-python"])
-        with self.assertNoLogs(self.api.logger, level="ERROR"):
-            status, data = await self.single(
-                {"path": "a.png", "root_index": 0, "model_type": "gguf"}
-            )
-        self.assertEqual((status, data["code"]), (409, "model-unavailable"))
-        self.assertIn("pip install llama-cpp-python", data["error"])
-        self.assertIsNone(model_gate.holder())
-
     async def test_each_refusal_is_one_error_frame(self):
         self.tagger.downloaded["wd14-vit"] = False
         _, frames = await self.legacy()

tests/test_autotag_packages.py

@@ -1,248 +0,0 @@
-"""#424: each tagging backend reports the Python packages it cannot import.
-
-``find_spec`` is patched throughout: no ML backend is installed or imported.
-"""
-
-import os
-import sys
-import types
-import unittest
-from unittest.mock import patch
-
-sys.path.insert(0, os.path.dirname(os.path.dirname(os.path.abspath(__file__))))
-
-try:
-    from test_autotag_engine import (
-        EngineTestCase,
-        FakeGgufModel,
-        _patch_modules,
-        _touch_model_files,
-    )
-except ImportError:  # pragma: no cover - run as a package
-    from tests.test_autotag_engine import (
-        EngineTestCase,
-        FakeGgufModel,
-        _patch_modules,
-        _touch_model_files,
-    )
-
-from py import autotag  # noqa: E402
-from py.autotag import (  # noqa: E402
-    BACKEND_PACKAGES,
-    MODELS,
-    AutoTagService,
-    MissingBackendPackages,
-    missing_packages,
-    package_fields,
-)
-
-GGUF_CUDA = 'For a CUDA build: CMAKE_ARGS="-DGGML_CUDA=on" pip install llama-cpp-python'
-
-
-def _find_spec_without(*absent):
-    """A ``find_spec`` that knows every module except *absent*."""
-
-    def find_spec(name, *args):
-        return None if name in absent else object()
-
-    return find_spec
-
-
-def _missing_from(*absent):
-    return patch.object(
-        autotag.importlib.util, "find_spec", side_effect=_find_spec_without(*absent)
-    )
-
-
-class TestMissingPackages(unittest.TestCase):
-
-    def test_every_backend_names_its_modules_and_pip_names(self):
-        self.assertEqual(BACKEND_PACKAGES["gguf"], (("llama_cpp", "llama-cpp-python"),))
-        self.assertEqual(
-            [pip for _module, pip in BACKEND_PACKAGES["hf"]],
-            ["torch", "transformers", "accelerate", "bitsandbytes"],
-        )
-        for model in ("wd14-swinv2", "wd14-vit"):
-            self.assertEqual(BACKEND_PACKAGES[model], (("onnxruntime", "onnxruntime"),))
-        self.assertEqual(set(BACKEND_PACKAGES), set(MODELS))
-
-    def test_reports_pip_names_of_modules_find_spec_cannot_find(self):
-        with _missing_from("llama_cpp", "accelerate", "bitsandbytes"):
-            self.assertEqual(missing_packages("gguf"), ["llama-cpp-python"])
-            self.assertEqual(missing_packages("hf"), ["accelerate", "bitsandbytes"])
-            self.assertEqual(missing_packages("wd14-vit"), [])
-
-    def test_find_spec_errors_count_as_missing(self):
-        for error in (ValueError("no spec"), ImportError("broken"), OSError("io")):
-            with self.subTest(error=type(error).__name__):
-                with patch.object(
-                    autotag.importlib.util, "find_spec", side_effect=error
-                ):
-                    self.assertEqual(missing_packages("wd14-vit"), ["onnxruntime"])
-
-    def test_a_module_already_imported_is_present_without_a_lookup(self):
-        with _patch_modules({"llama_cpp": types.ModuleType("llama_cpp")}):
-            with patch.object(
-                autotag.importlib.util, "find_spec", side_effect=AssertionError
-            ):
-                self.assertEqual(missing_packages("gguf"), [])
-
-    def test_the_check_imports_nothing(self):
-        before = set(sys.modules)
-        missing_packages("gguf")
-        missing_packages("hf")
-        missing_packages("wd14-vit")
-        imported = set(sys.modules) - before
-        heavy = {"llama_cpp", "torch", "transformers", "onnxruntime"}
-        self.assertFalse(imported & heavy, imported)
-
-    def test_unknown_model_has_no_packages(self):
-        self.assertEqual(missing_packages("nope"), [])
-
-    def test_package_fields_and_the_one_sentence(self):
-        self.assertEqual(
-            package_fields("gguf", []),
-            {"missing_packages": [], "install_command": None, "install_note": None},
-        )
-        fields = package_fields("gguf", ["llama-cpp-python"])
-        self.assertEqual(fields["missing_packages"], ["llama-cpp-python"])
-        self.assertEqual(fields["install_command"], "pip install llama-cpp-python")
-        self.assertEqual(fields["install_note"], GGUF_CUDA)
-        self.assertEqual(
-            package_fields("hf", ["torch", "bitsandbytes"])["install_command"],
-            "pip install torch bitsandbytes",
-        )
-        self.assertIsNone(package_fields("hf", ["torch"])["install_note"])
-        self.assertIn(
-            "onnxruntime-gpu",
-            package_fields("wd14-vit", ["onnxruntime"])["install_note"],
-        )
-        error = MissingBackendPackages("gguf", ["llama-cpp-python"])
-        self.assertIsInstance(error, RuntimeError)
-        self.assertEqual(
-            str(error),
-            "GGUF JoyCaption needs llama-cpp-python. Install it into ComfyUI's "
-            "Python: pip install llama-cpp-python. " + GGUF_CUDA,
-        )
-        self.assertEqual(
-            str(MissingBackendPackages("hf", ["accelerate", "bitsandbytes"])),
-            "HuggingFace JoyCaption needs accelerate and bitsandbytes. Install them "
-            "into ComfyUI's Python: pip install accelerate bitsandbytes.",
-        )
-
-
-class TestStatusReportsPackages(EngineTestCase):
-
-    def test_downloaded_keeps_its_files_only_meaning(self):
-        _touch_model_files(self.models_dir, "gguf")
-        _touch_model_files(self.models_dir, "wd14-vit")
-        service = AutoTagService(models_dir=self.models_dir)
-
-        with _missing_from("llama_cpp"):
-            status = service.get_models_status()
-
-        self.assertTrue(status["gguf"]["downloaded"])
-        self.assertEqual(status["gguf"]["missing_packages"], ["llama-cpp-python"])
-        self.assertEqual(
-            status["gguf"]["install_command"], "pip install llama-cpp-python"
-        )
-        self.assertEqual(status["gguf"]["install_note"], GGUF_CUDA)
-        self.assertEqual(status["wd14-vit"]["missing_packages"], [])
-        self.assertIsNone(status["wd14-vit"]["install_command"])
-        # A model not on disk still says which packages it will need.
-        self.assertFalse(status["wd14-swinv2"]["downloaded"])
-        self.assertIn("missing_packages", status["hf"])
-
-    def test_an_injected_loader_brings_its_own_backend(self):
-        service = self._service(("gguf", FakeGgufModel("x")))
-        with _missing_from("llama_cpp"):
-            self.assertEqual(
-                service.get_models_status()["gguf"]["missing_packages"], []
-            )
-
-    def test_an_injected_probe_is_used_for_status_and_load(self):
-        _touch_model_files(self.models_dir, "gguf")
-        service = AutoTagService(
-            models_dir=self.models_dir,
-            model_loader=lambda *_: ("gguf", FakeGgufModel("x")),
-            package_probe=lambda model_type: ["llama-cpp-python"],
-        )
-        self.assertEqual(
-            service.get_models_status()["gguf"]["missing_packages"],
-            ["llama-cpp-python"],
-        )
-        with self.assertRaises(MissingBackendPackages):
-            service.load_model("gguf")
-
-
-class TestLoadFailsFast(EngineTestCase):
-
-    def test_missing_package_refuses_before_the_loader_without_an_error_log(self):
-        _touch_model_files(self.models_dir, "gguf")
-        service = AutoTagService(models_dir=self.models_dir)
-        calls = []
-        service._model_loader = lambda *args: calls.append(args)
-
-        with (
-            _missing_from("llama_cpp"),
-            self.assertLogs(service.logger, level="DEBUG") as logs,
-        ):
-            with self.assertRaises(MissingBackendPackages) as ctx:
-                service.load_model("gguf")
-
-        self.assertEqual(calls, [])
-        self.assertEqual(ctx.exception.model_type, "gguf")
-        self.assertEqual(ctx.exception.missing, ["llama-cpp-python"])
-        self.assertIn("pip install llama-cpp-python", str(ctx.exception))
-        self.assertFalse(service.is_model_loaded())
-        levels = {record.levelname for record in logs.records}
-        self.assertNotIn("ERROR", levels)
-        self.assertIn("WARNING", levels)
-        self.assertTrue(all(record.exc_info is None for record in logs.records))
-
-    def test_not_downloaded_is_reported_before_packages(self):
-        service = AutoTagService(models_dir=self.models_dir)
-        with _missing_from("llama_cpp"):
-            with self.assertRaises(RuntimeError) as ctx:
-                service.load_model("gguf")
-        self.assertNotIsInstance(ctx.exception, MissingBackendPackages)
-
-    def test_a_module_not_found_from_the_loader_becomes_the_same_refusal(self):
-        _touch_model_files(self.models_dir, "gguf")
-
-        def loader(model_type, use_gpu):
-            raise ModuleNotFoundError("No module named 'llama_cpp'", name="llama_cpp")
-
-        service = AutoTagService(
-            models_dir=self.models_dir,
-            model_loader=loader,
-            package_probe=lambda _model: [],
-        )
-        with self.assertLogs(service.logger, level="DEBUG") as logs:
-            with self.assertRaises(MissingBackendPackages) as ctx:
-                service.load_model("gguf")
-        self.assertEqual(ctx.exception.missing, ["llama-cpp-python"])
-        self.assertNotIn("ERROR", {record.levelname for record in logs.records})
-        self.assertFalse(service.is_model_loaded())
-
-    def test_an_unknown_module_not_found_names_the_module(self):
-        def loader(model_type, use_gpu):
-            raise ModuleNotFoundError(
-                "No module named 'sentencepiece'", name="sentencepiece"
-            )
-
-        hf_dir = self.models_dir / MODELS["hf"]["subdir"]
-        hf_dir.mkdir(parents=True, exist_ok=True)
-        (hf_dir / "config.json").write_text("{}")
-        service = AutoTagService(
-            models_dir=self.models_dir,
-            model_loader=loader,
-            package_probe=lambda _model: [],
-        )
-        with self.assertRaises(MissingBackendPackages) as ctx:
-            service.load_model("hf")
-        self.assertEqual(ctx.exception.missing, ["sentencepiece"])
-
-
-if __name__ == "__main__":
-    unittest.main()

tests/test_database_backup.py

@@ -614,50 +614,6 @@ class TestRestoreFromFile(BackupTestCase):
             )
         assert_closed(self, str(backups[0]))
 
-    def test_backup_and_restore_keep_collections(self):
-        with self.db.model.get_connection() as conn:
-            conn.execute(
-                "INSERT INTO image_collections (id, name, name_key, created_at) "
-                "VALUES (4, 'LoRa testing', 'lora testing', '2026-10-27T00:00:00Z')"
-            )
-            conn.execute(
-                "INSERT INTO image_collection_items VALUES "
-                "(4, 'root', 'grid.png', '2026-10-27T00:00:00Z')"
-            )
-        with tempfile.TemporaryDirectory() as directory:
-            # The rows still sit in the WAL; a backup must carry them.
-            backup = os.path.join(directory, "backup.db")
-            self.assertTrue(self.db.model.backup_database(backup))
-            self.assertEqual(
-                PromptModel.verify_database_file(backup, require_library_state=True),
-                (True, "ok"),
-            )
-            with self.db.model.get_connection() as conn:
-                conn.execute("DELETE FROM image_collections")
-
-            self.db.model.restore_from_file(backup)
-
-            conn = self.db.model.get_connection()
-            self.assertEqual(
-                [
-                    tuple(r)
-                    for r in conn.execute("SELECT id, name FROM image_collections")
-                ],
-                [(4, "LoRa testing")],
-            )
-            self.assertEqual(
-                [
-                    tuple(r)
-                    for r in conn.execute(
-                        "SELECT collection_id, root_key, relative_path "
-                        "FROM image_collection_items"
-                    )
-                ],
-                [(4, "root", "grid.png")],
-            )
-            PromptModel.close_all_instances()
-            assert_closed(self, directory)
-
     def test_restore_without_a_live_database_returns_empty_backup_path(self):
         src = self._make_source_db(["fresh"])
         self.db.close_all()

tests/test_duplicate_image_categories.py

@@ -149,36 +149,3 @@ class TestDuplicateCleanupKeepsCategories(DuplicateFilesTestCase):
             kept = image_category_key([link], link / "a.png")
         self.assertFalse((self.output_dir / "b.png").exists())
         self.assertEqual(self.api.db.image_category(*kept), "Portraits")
-
-    async def test_a_copy_with_a_collection_and_a_category_moves_both(self):
-        # #331 + #332: one removed copy carries both records; one cleanup
-        # moves its membership and copies its category onto the kept copy.
-        self.trio()
-        db = self.api.db
-        root_key = duplicate_files.favorite_root_key(self.output_dir)
-        b = self.output_dir / "b.png"
-        grids = db.add_to_collection(name="LoRA grids", items=[(root_key, "b.png")])
-        grids = grids["collection"]["id"]
-        self.set_category(b, "Portraits")
-        seen = {}
-        real_log = duplicate_files.DuplicateFilesMixin._log_moved_records
-
-        def log_moved_records(job, totals):
-            seen.update(totals)
-            real_log(job, totals)
-
-        with patch.object(
-            duplicate_files.DuplicateFilesMixin,
-            "_log_moved_records",
-            staticmethod(log_moved_records),
-        ):
-            cleanup = await self.run_cleanup()
-        self.assertFalse(b.exists())
-        self.assertEqual(db.collection_members(grids, root_key), {"a.png"})
-        self.assertEqual(db.file_collections(root_key, "b.png"), [])
-        self.assertEqual(self.category(self.output_dir / "a.png"), "Portraits")
-        self.assertEqual(seen["collections"], 1)
-        self.assertEqual(seen["categories"], 1)
-        log = "\n".join(cleanup.log)
-        self.assertIn("Moved 1 collection membership to the kept copies", log)
-        self.assertIn("Kept 1 image category on the kept copies", log)

tests/test_image_collections.py

@@ -1,268 +0,0 @@
-"""Collections (#331): the database operations."""
-
-import sqlite3
-import tempfile
-import unittest
-from pathlib import Path
-from unittest.mock import patch
-
-try:
-    from tests.open_handles import assert_closed
-except ImportError:  # discovered with tests/ as the top-level directory
-    from open_handles import assert_closed
-
-from database.models import PromptModel
-from database.operations import PromptDatabase
-
-try:  # guarded so a missing module fails assertions, not test loading
-    from database.image_collections import (
-        CollectionFilesMissing,
-        CollectionInvalid,
-        CollectionMissing,
-        CollectionNameTaken,
-        READ_SQL,
-    )
-except ImportError:
-    CollectionFilesMissing = CollectionMissing = CollectionNameTaken = None
-    CollectionInvalid = ValueError
-    READ_SQL = None
-
-ROOT = "/real/output"
-OTHER = "/real/other"
-
-
-class ImageCollectionOperationsTests(unittest.TestCase):
-    def setUp(self):
-        self.temp = tempfile.TemporaryDirectory()
-        self.addCleanup(self.temp.cleanup)
-        self.addCleanup(assert_closed, self, self.temp.name)
-        self.addCleanup(PromptModel.reset_schema_cache)
-        self.db = PromptDatabase(str(Path(self.temp.name) / "prompts.db"))
-        self.addCleanup(self.db.close_all)
-
-    def require(self):
-        self.assertTrue(
-            hasattr(self.db, "add_to_collection"),
-            "ImageCollectionOperations is not implemented",
-        )
-
-    def add(self, items, **target):
-        return self.db.add_to_collection(items=items, **target)
-
-    def test_add_creates_a_collection_by_name(self):
-        self.require()
-        result = self.add(
-            [(ROOT, "a.png"), (ROOT, "b.png"), (OTHER, "a.png")], name="LoRa testing"
-        )
-        collection = result["collection"]
-        self.assertEqual(collection["name"], "LoRa testing")
-        self.assertEqual(
-            result,
-            {"collection": collection, "created": True, "added": 3, "already": 0},
-        )
-        self.assertEqual(self.db.list_collections(), [collection])
-        self.assertTrue(self.db.collection_exists(collection["id"]))
-        self.assertEqual(self.db.get_collection(collection["id"]), collection)
-        self.assertEqual(
-            self.db.collection_members(collection["id"], ROOT), {"a.png", "b.png"}
-        )
-        self.assertEqual(
-            self.db.root_collection_members(OTHER), {collection["id"]: {"a.png"}}
-        )
-        self.assertEqual(self.db.collection_counts(), {collection["id"]: 3})
-        self.assertEqual(self.db.file_collections(ROOT, "a.png"), [collection["id"]])
-        self.assertEqual(self.db.file_collections(ROOT, "zzz.png"), [])
-
-    def test_add_by_name_ignores_case_and_unicode_form(self):
-        self.require()
-        first = self.add([(ROOT, "a.png")], name="Café grids")["collection"]
-        # NFD spelling (macOS) in another case joins the same collection.
-        second = self.add([(ROOT, "b.png")], name="CAFÉ  GRIDS")
-        self.assertEqual(second["collection"], first)
-        self.assertFalse(second["created"])
-        self.assertEqual(len(self.db.list_collections()), 1)
-        self.assertEqual(
-            self.db.collection_members(first["id"], ROOT), {"a.png", "b.png"}
-        )
-
-    def test_add_counts_already_present(self):
-        self.require()
-        made = self.add([(ROOT, "a.png"), (ROOT, "b.png")], name="Set")
-        result = self.add(
-            [(ROOT, "b.png"), (ROOT, "c.png"), (ROOT, "c.png")],
-            collection_id=made["collection"]["id"],
-        )
-        self.assertEqual(
-            (result["created"], result["added"], result["already"]), (False, 1, 1)
-        )
-        self.assertEqual(self.db.collection_counts(), {made["collection"]["id"]: 3})
-
-    def test_add_with_a_new_name_and_nothing_inserted_creates_nothing(self):
-        self.require()
-        with self.assertRaises(CollectionFilesMissing):
-            self.add([], name="Empty")
-        self.assertEqual(self.db.list_collections(), [])
-        # An existing name with nothing to add is not an error.
-        made = self.add([(ROOT, "a.png")], name="Kept")["collection"]
-        self.assertEqual(
-            self.add([], name="kept"),
-            {"collection": made, "created": False, "added": 0, "already": 0},
-        )
-
-    def test_add_to_a_deleted_collection_raises_missing(self):
-        self.require()
-        made = self.add([(ROOT, "a.png")], name="Gone")["collection"]
-        self.db.delete_collection(made["id"])
-        with self.assertRaises(CollectionMissing):
-            self.add([(ROOT, "b.png")], collection_id=made["id"])
-        with self.assertRaises(CollectionMissing):
-            self.db.remove_from_collection(made["id"], [(ROOT, "a.png")])
-        with self.assertRaises(CollectionMissing):
-            self.db.rename_collection(made["id"], "Back")
-        self.assertFalse(self.db.collection_exists(made["id"]))
-        self.assertIsNone(self.db.get_collection(made["id"]))
-
-    def test_remove_returns_the_count(self):
-        self.require()
-        made = self.add([(ROOT, "a.png"), (ROOT, "b.png")], name="Set")["collection"]
-        result = self.db.remove_from_collection(
-            made["id"], [(ROOT, "a.png"), (ROOT, "a.png"), (ROOT, "never.png")]
-        )
-        self.assertEqual(result, {"collection": made, "removed": 1})
-        self.assertEqual(self.db.collection_members(made["id"], ROOT), {"b.png"})
-        # Removing the last member keeps the (now empty) collection.
-        self.db.remove_from_collection(made["id"], [(ROOT, "b.png")])
-        self.assertEqual(self.db.list_collections(), [made])
-        self.assertEqual(self.db.collection_counts(), {made["id"]: 0})
-
-    def test_rename_refuses_a_taken_name(self):
-        self.require()
-        first = self.add([(ROOT, "a.png")], name="First")["collection"]
-        second = self.add([(ROOT, "a.png")], name="Second")["collection"]
-        with self.assertRaises(CollectionNameTaken) as caught:
-            self.db.rename_collection(second["id"], " first ")
-        self.assertEqual(caught.exception.collection_id, first["id"])
-        self.assertEqual(self.db.get_collection(second["id"]), second)
-
-    def test_rename_accepts_a_case_variant_of_its_own_name(self):
-        self.require()
-        made = self.add([(ROOT, "a.png")], name="lora grids")["collection"]
-        renamed = self.db.rename_collection(made["id"], "LoRA   grids ")
-        self.assertEqual(renamed, {"id": made["id"], "name": "LoRA grids"})
-        self.assertEqual(self.db.list_collections(), [renamed])
-        other = self.db.rename_collection(made["id"], "Portraits")
-        self.assertEqual(other["name"], "Portraits")
-
-    def test_delete_unknown_raises_missing(self):
-        self.require()
-        made = self.add([(ROOT, "a.png")], name="Doomed")["collection"]
-        self.assertTrue(self.db.delete_collection(made["id"]))
-        self.assertEqual(self.db.root_collection_members(ROOT), {})
-        with self.assertRaises(CollectionMissing):
-            self.db.delete_collection(made["id"])
-        with self.assertRaises(CollectionMissing):
-            self.db.delete_collection(999)
-
-    def test_list_is_in_name_key_order(self):
-        self.require()
-        for name in ("beta", "Alpha", "été", "Zeta", "alpha two"):
-            self.add([(ROOT, "a.png")], name=name)
-        self.assertEqual(
-            [row["name"] for row in self.db.list_collections()],
-            ["Alpha", "alpha two", "beta", "Zeta", "été"],
-        )
-
-    def test_names_are_trimmed_and_collapsed(self):
-        self.require()
-        made = self.add([(ROOT, "a.png")], name="  LoRa \t testing\n ")["collection"]
-        self.assertEqual(made["name"], "LoRa testing")
-        for bad in ("", "   ", "x" * 101, "bell\x07", "c1\x81", "del\x7f", 5, None):
-            with self.subTest(name=bad):
-                with self.assertRaises(CollectionInvalid):
-                    self.add([(ROOT, "a.png")], name=bad)
-        self.assertEqual(len(self.db.list_collections()), 1)
-
-    def test_targets_and_items_are_validated(self):
-        self.require()
-        made = self.add([(ROOT, "a.png")], name="Set")["collection"]
-        for target in (
-            {},
-            {"name": "x", "collection_id": made["id"]},
-            {"collection_id": True},
-            {"collection_id": 0},
-            {"collection_id": "1"},
-        ):
-            with self.subTest(target=target):
-                with self.assertRaises(CollectionInvalid):
-                    self.add([(ROOT, "a.png")], **target)
-        for items in ([("root",)], [(ROOT, 5)], "a.png", [(ROOT, "x" * 4097)]):
-            with self.subTest(items=items):
-                with self.assertRaises(CollectionInvalid):
-                    self.add(items, collection_id=made["id"])
-
-    def test_a_failure_after_the_membership_move_rolls_it_back(self):
-        self.require()
-        made = self.add([(ROOT, "b.png")], name="Grids")["collection"]
-        move = {
-            "removed": [],
-            "kept": [],
-            "targets": {},
-            "kept_path": "/real/output/a.png",
-            "favorites": [(ROOT, "b.png", ROOT, "a.png")],
-            "removed_locator": "/real/output/b.png",
-            "kept_locator": "/real/output/a.png",
-            "sha256": "0" * 64,
-            "kept_size": 1,
-            "kept_mtime_ns": 1,
-        }
-        with patch.object(
-            type(self.db), "_move_copy_tags", side_effect=RuntimeError("boom")
-        ):
-            with self.assertRaises(RuntimeError):
-                self.db.move_copy_records(move)
-        self.assertEqual(self.db.file_collections(ROOT, "b.png"), [made["id"]])
-        self.assertEqual(self.db.file_collections(ROOT, "a.png"), [])
-        # Without the failure the same move succeeds.
-        self.assertEqual(self.db.move_copy_records(move)["collections"], 1)
-        self.assertEqual(self.db.file_collections(ROOT, "a.png"), [made["id"]])
-
-    def test_count_snapshot_reads_in_one_transaction(self):
-        self.require()
-        made = self.add([(ROOT, "a.png"), (OTHER, "b.png")], name="Set")["collection"]
-        statements = []
-        conn = self.db.model.get_connection()
-        conn.set_trace_callback(statements.append)
-        try:
-            members, stored = self.db.collection_count_snapshot([ROOT, OTHER, ROOT])
-        finally:
-            conn.set_trace_callback(None)
-        self.assertEqual(
-            members, {ROOT: {made["id"]: {"a.png"}}, OTHER: {made["id"]: {"b.png"}}}
-        )
-        self.assertEqual(stored, {made["id"]: 2})
-        self.assertEqual(statements[0], "BEGIN")
-        self.assertEqual(statements[-1], "ROLLBACK")
-        self.assertFalse(conn.in_transaction)
-
-    def test_reads_use_an_index(self):
-        self.require()
-        self.add([(ROOT, "a.png")], name="Set")
-        conn = sqlite3.connect(self.db.model.db_path)
-        try:
-            for sql in READ_SQL:
-                plan = " ".join(
-                    row[3]
-                    for row in conn.execute(
-                        "EXPLAIN QUERY PLAN " + sql, [None] * sql.count("?")
-                    )
-                )
-                with self.subTest(sql=sql):
-                    self.assertNotIn("SCAN image_collection_items", plan)
-                    if "?" in sql:  # a lookup, not the whole list
-                        self.assertNotIn("SCAN image_collections", plan)
-        finally:
-            conn.close()
-
-
-if __name__ == "__main__":
-    unittest.main()

tests/test_image_collections_schema.py

@@ -1,521 +0,0 @@
-"""Collections schema (#331): install, validation and restore safety."""
-
-import re
-import sqlite3
-import tempfile
-import unittest
-import unicodedata
-from contextlib import closing
-from pathlib import Path
-from unittest.mock import patch
-
-try:
-    from tests.open_handles import assert_closed
-    from tests.test_annotation_schema import LEGACY_TABLES, table_rows
-except ImportError:  # discovered with tests/ as the top-level directory
-    from open_handles import assert_closed
-    from test_annotation_schema import LEGACY_TABLES, table_rows
-
-from database.models import PromptModel
-
-try:  # guarded so a missing module fails assertions, not test loading
-    from database import image_collections
-    from database.image_collections import (
-        image_collections_schema_error,
-        migrate_image_collections,
-    )
-except ImportError:
-    image_collections = None
-    image_collections_schema_error = None
-    migrate_image_collections = None
-
-COLLECTIONS = "image_collections"
-ITEMS = "image_collection_items"
-INDEX = "idx_image_collection_items_file"
-TABLES = (COLLECTIONS, ITEMS)
-DDL = {
-    COLLECTIONS: (
-        f"CREATE TABLE {COLLECTIONS} (id INTEGER PRIMARY KEY AUTOINCREMENT, "
-        "name TEXT NOT NULL, name_key TEXT NOT NULL UNIQUE, "
-        "created_at TEXT NOT NULL)"
-    ),
-    ITEMS: (
-        f"CREATE TABLE {ITEMS} (collection_id INTEGER NOT NULL REFERENCES "
-        f"{COLLECTIONS}(id) ON DELETE CASCADE, root_key TEXT NOT NULL, "
-        "relative_path TEXT NOT NULL, added_at TEXT NOT NULL, "
-        "PRIMARY KEY (collection_id, root_key, relative_path))"
-    ),
-}
-INDEX_DDL = f"CREATE INDEX {INDEX} ON {ITEMS}(root_key, relative_path)"
-NOW = "2026-10-27T00:00:00.000000+00:00"
-IMAGES = 23_000
-
-
-def _compact(sql):
-    return re.sub(r"\s+", "", sql or "").lower()
-
-
-def expected_catalog():
-    return {
-        ("table", COLLECTIONS, _compact(DDL[COLLECTIONS])),
-        ("table", ITEMS, _compact(DDL[ITEMS])),
-        ("index", INDEX, _compact(INDEX_DDL)),
-        ("index", f"sqlite_autoindex_{COLLECTIONS}_1", ""),
-        ("index", f"sqlite_autoindex_{ITEMS}_1", ""),
-    }
-
-
-def catalog(conn):
-    return {
-        (kind, name, _compact(sql))
-        for kind, name, sql in conn.execute(
-            "SELECT type,name,sql FROM sqlite_master "
-            "WHERE name IN (?,?,?) OR tbl_name IN (?,?)",
-            (*TABLES, INDEX, *TABLES),
-        )
-    }
-
-
-def key(name):
-    return unicodedata.normalize("NFC", unicodedata.normalize("NFC", name).casefold())
-
-
-def schema(conn, exclude=()):
-    return sorted(
-        tuple(row)
-        for row in conn.execute(
-            "SELECT type,name,tbl_name,sql FROM sqlite_master ORDER BY name"
-        )
-        if row[1] not in exclude and row[2] not in exclude
-    )
-
-
-def row_counts(conn):
-    tables = [
-        name
-        for (name,) in conn.execute(
-            "SELECT name FROM sqlite_master WHERE type='table' ORDER BY name"
-        )
-    ]
-    return {
-        table: conn.execute(f"SELECT COUNT(*) FROM {table}").fetchone()[0]  # nosec
-        for table in tables
-    }
-
-
-class ImageCollectionsSchemaTests(unittest.TestCase):
-    def setUp(self):
-        self.temp = tempfile.TemporaryDirectory()
-        self.addCleanup(self.temp.cleanup)
-        self.addCleanup(assert_closed, self, self.temp.name)
-        self.addCleanup(PromptModel.reset_schema_cache)
-        self.models = []
-        self.addCleanup(self.close_models)
-        self.path = str(Path(self.temp.name) / "live.db")
-
-    def close_models(self):
-        for model in self.models:
-            model.close_all()
-
-    def model(self, path=None):
-        model = PromptModel(path or self.path)
-        self.models.append(model)
-        return model
-
-    def require_module(self):
-        self.assertIsNotNone(
-            image_collections_schema_error,
-            "database.image_collections is not implemented",
-        )
-
-    def closed_current(self, name="current.db", *statements):
-        """A closed current database, altered afterwards by *statements*."""
-        path = str(Path(self.temp.name) / name)
-        model = self.model(path)
-        model.close_all()
-        PromptModel.reset_schema_cache()
-        with closing(sqlite3.connect(path)) as raw, raw:
-            raw.execute("PRAGMA foreign_keys=OFF")
-            for statement in statements:
-                if isinstance(statement, tuple):
-                    raw.execute(*statement)
-                else:
-                    raw.execute(statement)
-        return path
-
-    @staticmethod
-    def drop_group(path):
-        with closing(sqlite3.connect(path)) as raw, raw:
-            raw.execute(f"DROP TABLE {ITEMS}")
-            raw.execute(f"DROP TABLE {COLLECTIONS}")
-
-    def test_migration_creates_tables_and_index(self):
-        self.require_module()
-        model = self.model()
-        with model.get_connection() as conn:
-            self.assertEqual(catalog(conn), expected_catalog())
-            self.assertIsNone(image_collections_schema_error(conn, allow_missing=False))
-            self.assertEqual(
-                conn.execute(f"SELECT COUNT(*) FROM {COLLECTIONS}").fetchone()[0], 0
-            )
-            self.assertEqual(
-                conn.execute(f"SELECT COUNT(*) FROM {ITEMS}").fetchone()[0], 0
-            )
-        self.assertEqual(
-            PromptModel.verify_database_file(self.path, require_library_state=True),
-            (True, "ok"),
-        )
-
-    def test_migration_is_idempotent(self):
-        self.require_module()
-        model = self.model()
-        with model.get_connection() as conn:
-            conn.execute(
-                f"INSERT INTO {COLLECTIONS} (name, name_key, created_at) "
-                "VALUES ('Kept', 'kept', ?)",
-                (NOW,),
-            )
-            conn.execute(f"INSERT INTO {ITEMS} VALUES (1, 'root', 'a.png', ?)", (NOW,))
-            before = schema(conn)
-        model.close_all()
-        for _ in range(2):
-            PromptModel.reset_schema_cache()
-            model = self.model()
-            with model.get_connection() as conn:
-                migrate_image_collections(conn)
-                self.assertEqual(schema(conn), before)
-                self.assertEqual(
-                    [tuple(r) for r in conn.execute(f"SELECT * FROM {ITEMS}")],
-                    [(1, "root", "a.png", NOW)],
-                )
-            model.close_all()
-
-    def test_migration_reads_only_its_own_tables(self):
-        self.require_module()
-        model = self.model()
-        with model.get_connection() as conn:
-            conn.execute("INSERT INTO prompts(id,text,hash) VALUES(1,'positive','p')")
-            conn.executemany(
-                "INSERT INTO generated_images(prompt_id,image_path,filename,"
-                "file_path) VALUES(1,?,?,?)",
-                ((f"/out/{n}.png", f"{n}.png", f"/out/{n}.png") for n in range(IMAGES)),
-            )
-            conn.execute("INSERT INTO image_favorites VALUES('root','a.png',?)", (NOW,))
-        model.close_all()
-        self.drop_group(self.path)
-        with closing(sqlite3.connect(self.path)) as raw:
-            raw.execute("PRAGMA foreign_keys=ON")
-            counts_before = row_counts(raw)
-            schema_before = schema(raw)
-            legacy_before = table_rows(raw, LEGACY_TABLES)
-            self.assertEqual(counts_before["generated_images"], IMAGES)
-            touched = []
-
-            def record(action, arg1, arg2, _db, _trigger):
-                touched.append((action, arg1, arg2))
-                return sqlite3.SQLITE_OK
-
-            raw.set_authorizer(record)
-            try:
-                migrate_image_collections(raw)
-            finally:
-                raw.set_authorizer(None)
-            raw.commit()
-            reads = {
-                arg1 for action, arg1, _arg2 in touched if action == sqlite3.SQLITE_READ
-            }
-            self.assertTrue(reads)
-            self.assertLessEqual(reads, {"sqlite_master", COLLECTIONS, ITEMS})
-            writes = {
-                arg1
-                for action, arg1, _arg2 in touched
-                if action
-                in (sqlite3.SQLITE_INSERT, sqlite3.SQLITE_UPDATE, sqlite3.SQLITE_DELETE)
-            }
-            self.assertLessEqual(writes, {"sqlite_master"})
-            self.assertEqual(catalog(raw), expected_catalog())
-            counts_after = row_counts(raw)
-            self.assertEqual(counts_after.pop(COLLECTIONS), 0)
-            self.assertEqual(counts_after.pop(ITEMS), 0)
-            self.assertEqual(counts_after, counts_before)
-            self.assertEqual(schema(raw, exclude=TABLES), schema_before)
-            self.assertEqual(table_rows(raw, LEGACY_TABLES), legacy_before)
-            # A second run is a no-op.
-            after_first = schema(raw)
-            changes = raw.total_changes
-            migrate_image_collections(raw)
-            raw.commit()
-            self.assertEqual(schema(raw), after_first)
-            self.assertEqual(raw.total_changes, changes)
-
-    def test_migration_refuses_a_foreign_object_of_the_same_name(self):
-        self.require_module()
-        for statements in (
-            (f"CREATE TABLE {COLLECTIONS} (x)",),
-            (f"CREATE VIEW {COLLECTIONS} AS SELECT 1",),
-            (f"CREATE INDEX {INDEX} ON prompts(text)",),
-        ):
-            with self.subTest(statements=statements):
-                path = str(Path(self.temp.name) / f"foreign{len(self.models)}.db")
-                self.model(path).close_all()
-                PromptModel.reset_schema_cache()
-                self.drop_group(path)
-                with closing(sqlite3.connect(path)) as raw, raw:
-                    for statement in statements:
-                        raw.execute(statement)
-                with closing(sqlite3.connect(path)) as raw:
-                    before = schema(raw)
-                    self.assertIsNotNone(image_collections_schema_error(raw))
-                with self.assertRaises(sqlite3.DatabaseError):
-                    self.model(path).get_connection()
-                PromptModel.close_all_instances()
-                PromptModel.reset_schema_cache()
-                with closing(sqlite3.connect(path)) as raw:
-                    self.assertEqual(schema(raw), before)
-                    self.assertIsNone(
-                        raw.execute(
-                            "SELECT 1 FROM sqlite_master WHERE name=?", (ITEMS,)
-                        ).fetchone()
-                    )
-                self.assertFalse(PromptModel.verify_database_file(path)[0])
-
-    def test_migration_rolls_back_on_error(self):
-        self.require_module()
-        self.model().close_all()
-        PromptModel.reset_schema_cache()
-        self.drop_group(self.path)
-        with closing(sqlite3.connect(self.path)) as raw:
-            with patch.object(
-                image_collections,
-                "image_collections_schema_error",
-                side_effect=[None, "Image collections went wrong"],
-            ):
-                with self.assertRaisesRegex(sqlite3.DatabaseError, "went wrong"):
-                    migrate_image_collections(raw)
-            raw.commit()
-            self.assertEqual(catalog(raw), set())
-
-    def test_startup_accepts_a_value_saved_under_older_rules(self):
-        self.require_module()
-        path = self.closed_current(
-            "older.db",
-            (
-                f"INSERT INTO {COLLECTIONS} (name, name_key, created_at) "
-                "VALUES (?, 'not the key', ?)",
-                (" " + "x" * 150 + " ", NOW),
-            ),
-        )
-        model = self.model(path)
-        with model.get_connection() as conn:
-            self.assertIsNone(image_collections_schema_error(conn, check_values=False))
-            self.assertIsNotNone(image_collections_schema_error(conn))
-            self.assertEqual(
-                conn.execute(f"SELECT COUNT(*) FROM {COLLECTIONS}").fetchone()[0], 1
-            )
-        model.close_all()
-        self.assertFalse(
-            PromptModel.verify_database_file(path, require_library_state=True)[0]
-        )
-
-    def test_restore_accepts_an_old_backup_without_collections(self):
-        self.require_module()
-        path = self.closed_current("old.db")
-        self.drop_group(path)
-        with closing(sqlite3.connect(path)) as raw:
-            self.assertIsNone(image_collections_schema_error(raw))
-            self.assertEqual(
-                image_collections_schema_error(raw, allow_missing=False),
-                "Missing image collections schema",
-            )
-        self.assertEqual(PromptModel.verify_database_file(path), (True, "ok"))
-        model = self.model(path)
-        with model.get_connection() as conn:
-            self.assertEqual(catalog(conn), expected_catalog())
-        model.close_all()
-        self.assertEqual(
-            PromptModel.verify_database_file(path, require_library_state=True),
-            (True, "ok"),
-        )
-
-    def test_restore_requires_collections_on_a_current_stage(self):
-        self.require_module()
-        path = self.closed_current("stage.db")
-        self.drop_group(path)
-        self.assertEqual(
-            PromptModel.verify_database_file(path, require_library_state=True),
-            (False, "Missing image collections schema"),
-        )
-        # One table without the other is never acceptable.
-        partial = self.closed_current("partial.db", f"DROP TABLE {ITEMS}")
-        self.assertFalse(PromptModel.verify_database_file(partial)[0])
-
-    def assert_refused(self, name, *statements):
-        self.require_module()
-        path = self.closed_current(
-            f"{name}.db",
-            (
-                f"INSERT INTO {COLLECTIONS} (id, name, name_key, created_at) "
-                "VALUES (1, 'Good', 'good', ?)",
-                (NOW,),
-            ),
-            (f"INSERT INTO {ITEMS} VALUES (1, 'root', 'a.png', ?)", (NOW,)),
-            *statements,
-        )
-        with closing(sqlite3.connect(path)) as raw:
-            self.assertIsNone(image_collections_schema_error(raw, check_values=False))
-            error = image_collections_schema_error(raw)
-        self.assertIsNotNone(error)
-        self.assertIn("collections", error.lower())
-        ok, reason = PromptModel.verify_database_file(path)
-        self.assertFalse(ok)
-        self.assertEqual(reason, error)
-        self.assertFalse(
-            PromptModel.verify_database_file(path, require_library_state=True)[0]
-        )
-
-    def test_a_valid_current_database_is_accepted(self):
-        self.require_module()
-        path = self.closed_current(
-            "valid.db",
-            (
-                f"INSERT INTO {COLLECTIONS} (id, name, name_key, created_at) "
-                "VALUES (1, ?, ?, ?)",
-                ("LoRa testing", key("LoRa testing"), NOW),
-            ),
-            (f"INSERT INTO {ITEMS} VALUES (1, 'root', ?, ?)", ("é" * 4096, NOW)),
-        )
-        self.assertEqual(
-            PromptModel.verify_database_file(path, require_library_state=True),
-            (True, "ok"),
-        )
-
-    def test_restore_refuses_a_non_text_name(self):
-        # Column affinity turns a number into text; a blob stays a blob.
-        self.assert_refused("blob-name", f"UPDATE {COLLECTIONS} SET name = x'61'")
-
-    def test_restore_refuses_an_empty_name(self):
-        self.assert_refused("empty", f"UPDATE {COLLECTIONS} SET name = '', name_key=''")
-
-    def test_restore_refuses_a_name_over_100_characters(self):
-        name = "é" * 101
-        self.assert_refused(
-            "long",
-            (f"UPDATE {COLLECTIONS} SET name = ?, name_key = ?", (name, key(name))),
-        )
-
-    def test_restore_refuses_a_control_character(self):
-        name = "a\x07b"
-        self.assert_refused(
-            "control",
-            (f"UPDATE {COLLECTIONS} SET name = ?, name_key = ?", (name, key(name))),
-        )
-
-    def test_restore_refuses_a_leading_or_trailing_space(self):
-        for name in (" Good", "Good "):
-            with self.subTest(name=name):
-                self.assert_refused(
-                    f"padded{len(name)}{name[0] == ' '}",
-                    (
-                        f"UPDATE {COLLECTIONS} SET name = ?, name_key = ?",
-                        (name, key(name)),
-                    ),
-                )
-
-    def test_restore_accepts_a_name_key_from_other_case_tables(self):
-        # Python versions fold some characters differently; a key written
-        # by another version must never make a backup unrestorable.
-        self.require_module()
-        path = self.closed_current(
-            "other-key.db",
-            (
-                f"INSERT INTO {COLLECTIONS} (id, name, name_key, created_at) "
-                "VALUES (1, 'Good', 'Good', ?)",
-                (NOW,),
-            ),
-        )
-        self.assertEqual(
-            PromptModel.verify_database_file(path, require_library_state=True),
-            (True, "ok"),
-        )
-
-    def test_restore_refuses_an_empty_or_non_text_name_key(self):
-        self.assert_refused("empty-key", f"UPDATE {COLLECTIONS} SET name_key = ''")
-        self.assert_refused(
-            "blob-name-key", f"UPDATE {COLLECTIONS} SET name_key = x'61'"
-        )
-        self.assert_refused(
-            "long-name-key",
-            (f"UPDATE {COLLECTIONS} SET name_key = ?", ("k" * 1201,)),
-        )
-
-    def test_restore_refuses_a_c1_control_character(self):
-        for name in ("a\x81b", "a\x7fb"):
-            with self.subTest(name=repr(name)):
-                self.assert_refused(
-                    f"c1-{ord(name[1])}",
-                    (
-                        f"UPDATE {COLLECTIONS} SET name = ?, name_key = ?",
-                        (name, key(name)),
-                    ),
-                )
-
-    def test_restore_refuses_a_non_text_key(self):
-        # Column affinity turns a number into text; a blob stays a blob.
-        self.assert_refused("blob-key", f"UPDATE {ITEMS} SET relative_path = x'61'")
-
-    def test_restore_refuses_a_key_over_4096_characters(self):
-        self.assert_refused(
-            "long-key", (f"UPDATE {ITEMS} SET root_key = ?", ("é" * 4097,))
-        )
-
-    def test_restore_refuses_a_timestamp_over_64_bytes(self):
-        self.assert_refused(
-            "stamp", (f"UPDATE {COLLECTIONS} SET created_at = ?", ("t" * 65,))
-        )
-        self.assert_refused(
-            "item-stamp", (f"UPDATE {ITEMS} SET added_at = ?", ("t" * 65,))
-        )
-
-    def test_restore_refuses_an_item_of_a_missing_collection(self):
-        self.assert_refused("orphan", f"INSERT INTO {ITEMS} VALUES (9, 'r', 'b', 'n')")
-
-    def test_restore_refuses_a_non_integer_collection_id(self):
-        self.assert_refused("text-id", f"UPDATE {ITEMS} SET collection_id = 'one'")
-
-    def test_restore_refuses_a_trigger_or_extra_index(self):
-        self.require_module()
-        for name, statement in (
-            (
-                "trigger",
-                f"CREATE TRIGGER t AFTER INSERT ON {ITEMS} BEGIN SELECT 1; END",
-            ),
-            ("extra", f"CREATE INDEX extra ON {COLLECTIONS}(name)"),
-        ):
-            with self.subTest(name=name):
-                path = self.closed_current(f"{name}.db", statement)
-                with closing(sqlite3.connect(path)) as raw:
-                    self.assertIsNotNone(image_collections_schema_error(raw))
-                self.assertFalse(PromptModel.verify_database_file(path)[0])
-
-    def test_deleting_a_collection_deletes_its_members(self):
-        self.require_module()
-        model = self.model()
-        with model.get_connection() as conn:
-            conn.execute(
-                f"INSERT INTO {COLLECTIONS} (id, name, name_key, created_at) "
-                "VALUES (1, 'A', 'a', ?), (2, 'B', 'b', ?)",
-                (NOW, NOW),
-            )
-            conn.executemany(
-                f"INSERT INTO {ITEMS} VALUES (?, 'root', ?, ?)",
-                ((1, "a.png", NOW), (1, "b.png", NOW), (2, "a.png", NOW)),
-            )
-            conn.execute(f"DELETE FROM {COLLECTIONS} WHERE id = 1")
-            self.assertEqual(
-                [tuple(r) for r in conn.execute(f"SELECT collection_id FROM {ITEMS}")],
-                [(2,)],
-            )
-
-
-if __name__ == "__main__":
-    unittest.main()

tests/test_image_tag_jobs.py

@@ -299,19 +299,6 @@ class TestAutoTag(ImageTagJobTestCase):
         self.tagger.download_model.assert_not_called()
         self.assertIsNone(model_gate.holder())
 
-    async def test_a_missing_backend_package_fails_the_job_before_the_first_file(self):
-        self.png("a.png")
-        self.tagger.missing["wd14-vit"] = ["onnxruntime"]
-
-        with self.assertNoLogs(self.api.logger, level="ERROR"):
-            job = await self.run_job(self.auto_body(["a.png"]))
-
-        self.assertEqual(job.state, "failed")
-        self.assertEqual(job.processed, 0)
-        self.assertTrue(job.status_line.startswith("WD14 ViT needs onnxruntime."))
-        self.assertIn("pip install onnxruntime", job.status_line)
-        self.assertEqual(self.tagger.load_calls, [])
-
     async def test_model_unavailable_fails_the_job_before_the_first_file(self):
         self.png("a.png")
         self.tagger.downloaded["wd14-vit"] = False
@@ -897,16 +884,6 @@ class TestFilterStart(ImageTagJobTestCase):
         self.assertEqual((status, data["code"]), (400, "no-images"))
         self.assertEqual(self.api._jobs.list(), [])
 
-    async def test_filter_with_a_deleted_collection_is_a_404_without_a_job(self):
-        self.png("a.png")
-
-        status, data = await self.start(
-            {"mode": "add", "filter": {"collection": "77"}, "tags": ["x"]}
-        )
-
-        self.assertEqual((status, data["code"]), (404, "collection-not-found"))
-        self.assertEqual(self.api._jobs.list(), [])
-
     async def test_filter_over_the_cap_is_refused_without_a_job(self):
         from py.api import image_tag_jobs
 

tests/test_restore_plans.py

@@ -49,7 +49,6 @@ SUMMARY_KEYS = {
     "image_links",
     "runs",
     "saved_views",
-    "collections",
 }
 
 

tests/test_restore_stage.py

@@ -226,7 +226,6 @@ class TestStageAndPublish(StageTestCase):
             for key in ("pairs", "archived_pairs", "image_links", "runs"):
                 self.assertEqual(staged.summary[key], 0, key)
             self.assertEqual(staged.summary["saved_views"], 0)
-            self.assertEqual(staged.summary["collections"], 0)
             self.assertEqual(staged.schema, {"migrated": False, "library_state": True})
             self.assertEqual(
                 staged.digest,
@@ -240,48 +239,6 @@ class TestStageAndPublish(StageTestCase):
             staged.discard()
 
 
-class TestCollectionsSummary(StageTestCase):
-    """#331: collections join the review's summary and the live fingerprint."""
-
-    def add_collection(self, db, name):
-        with db.model.get_connection() as conn:
-            conn.execute(
-                "INSERT INTO image_collections (name, name_key, created_at) "
-                "VALUES (?, ?, '2026-10-27T00:00:00+00:00')",
-                (name, name.casefold()),
-            )
-
-    def test_summary_counts_collections(self):
-        src_path = os.path.join(self.uploads, "with-collections.db")
-        src = PromptDatabase(src_path)
-        try:
-            self.save(src, "kept")
-            self.add_collection(src, "First")
-            self.add_collection(src, "Second")
-        finally:
-            src.close_all()
-        staged = self.db.model.stage_restore(src_path)
-        try:
-            self.assertEqual(staged.summary["collections"], 2)
-        finally:
-            staged.discard()
-        self.assertIn("collections", restore_stage.SUMMARY_KEYS)
-
-    def test_adding_a_collection_changes_the_fingerprint(self):
-        conn = self.db.model.get_connection()
-        summary, before = restore_stage.live_fingerprint(conn)
-        self.assertEqual(summary["collections"], 0)
-        self.add_collection(self.db, "After the review")
-        summary, after = restore_stage.live_fingerprint(conn)
-        self.assertEqual(summary["collections"], 1)
-        self.assertNotEqual(after, before)
-        # A delete and a re-add with the same count still changes it (rowid).
-        with self.db.model.get_connection() as write:
-            write.execute("DELETE FROM image_collections")
-        self.add_collection(self.db, "Replacement")
-        self.assertNotEqual(restore_stage.live_fingerprint(conn)[1], after)
-
-
 class TestOlderBackups(StageTestCase):
     """Rollback-journal and older-schema backups restore exactly as before."""
 

tests/vendor/browser-coverage.test.mjs

@@ -27,23 +27,3 @@ test('browser coverage maps nested JS/MJS and excludes unrelated and traversal p
     const root = fileURLToPath(new URL('../../web/js/', import.meta.url));
     assert.deepEqual(report.result.map(entry => fileURLToPath(entry.url)), [join(root, 'gallery.js'), join(root, 'shared/controls/button.mjs'), join(root, 'shared/panel.js')]);
 });
-
-// #432: every raw file repeated each script's full source (about 84% of its bytes) and the coverage merge ran out of
-// memory. c8 reads the source from the mapped file on disk, so the entries keep only the URL, id and functions.
-test('browser coverage writes no script source, only what c8 maps', async t => {
-    const directory = mkdtempSync(join(tmpdir(), 'pm-browser-coverage-'));
-    const previous = process.env.PM_JS_COVERAGE;
-    process.env.PM_JS_COVERAGE = directory;
-    t.after(() => {
-        if (previous === undefined) delete process.env.PM_JS_COVERAGE;
-        else process.env.PM_JS_COVERAGE = previous;
-        rmSync(directory, { recursive: true, force: true });
-    });
-    const functions = [{ functionName: 'f', isBlockCoverage: true, ranges: [{ startOffset: 0, endOffset: 9, count: 1 }] }];
-    await saveCoverage({ coverage: { stopJSCoverage: async () => [{ url: 'http://127.0.0.1:8765/prompt_manager/js/gallery.js',
-        scriptId: '7', source: 'x'.repeat(100_000), functions }] } }, 'chromium');
-    const report = JSON.parse(readFileSync(join(directory, readdirSync(directory)[0]), 'utf8'));
-    assert.equal(report.result.length, 1);
-    assert.deepEqual(Object.keys(report.result[0]).sort(), ['functions', 'scriptId', 'url']);
-    assert.deepEqual(report.result[0].functions, functions);
-});

tests/vendor/browser-server-fixture.test.mjs

@@ -2,14 +2,12 @@ import test from 'node:test';
 import assert from 'node:assert/strict';
 import { createServer } from 'node:net';
 import { spawn } from 'node:child_process';
-import { EventEmitter, once } from 'node:events';
+import { once } from 'node:events';
 import { readFileSync } from 'node:fs';
-import { isAbsolute } from 'node:path';
 import { fileURLToPath, pathToFileURL } from 'node:url';
 import { setTimeout as delay } from 'node:timers/promises';
 import { startBrowserServer, createServerSupervisor, attachServerStderr, forwardPrefixedLines, SLOW_RESET_PREFIX } from '../../tools/vendor/start-browser-server.mjs';
-import { reporters, workflowWorkers } from '../../tools/vendor/test-workers.mjs';
-import RunningTestsReporter from '../../tools/vendor/running-tests-reporter.mjs';
+import { workflowWorkers } from '../../tools/vendor/test-workers.mjs';
 
 const fakeServer = fileURLToPath(new URL('./fake-browser-server.mjs', import.meta.url));
 const fake = (...extra) => ({ command: process.execPath, args: port => [fakeServer, '--port', String(port), ...extra] });
@@ -257,57 +255,3 @@ test('worker count follows PM_TEST_WORKERS, then one in CI, then a quarter of th
     assert.throws(() => workflowWorkers({ env: { PM_TEST_WORKERS: 'many' }, cpus: 8 }), /PM_TEST_WORKERS must be a positive integer/);
     assert.throws(() => workflowWorkers({ env: { PM_TEST_WORKERS: '0' }, cpus: 8 }), /PM_TEST_WORKERS must be a positive integer/);
 });
-
-test('CI adds the running-tests reporter and a blob report under test-results/blob/, which the trace upload covers; local runs keep list', () => {
-    assert.equal(reporters({ env: {}, name: 'workflows' }), 'list');
-    const [list, running, blob] = reporters({ env: { CI: '1' }, name: 'workflows' });
-    assert.deepEqual(list, ['list']);
-    // Absolute: a config imported from another directory (workflow-artifacts.test.mjs) still finds it.
-    assert.ok(isAbsolute(running[0]) && running[0].endsWith('running-tests-reporter.mjs'), running[0]);
-    assert.deepEqual(blob, ['blob', { outputDir: './test-results/blob/workflows' }]);
-});
-
-function fakeHost() {
-    const host = new EventEmitter();
-    Object.assign(host, { pid: 4242, signals: [], cwd: () => '/repo/tools/vendor' });
-    host.kill = (pid, signal) => host.signals.push([pid, signal]);
-    return host;
-}
-
-const spec = (id, title, line) => ({ id, title, location: { file: '/repo/tests/browser/a.spec.mjs', line },
-    parent: { project: () => ({ name: 'firefox' }) } });
-
-test('the running-tests reporter names only the tests that never ended, relative to rootDir', () => {
-    let clock = 1_000;
-    const output = [];
-    const host = fakeHost();
-    const reporter = new RunningTestsReporter({ now: () => clock, write: text => output.push(text), host });
-    reporter.onBegin({ rootDir: '/repo/tests/browser' });
-    const done = spec('1', 'finishes', 10);
-    const stuck = spec('2', 'hangs on a fetch', 20);
-    reporter.onTestBegin(done, { retry: 0 });
-    reporter.onTestBegin(stuck, { retry: 0 });
-    clock += 500;
-    reporter.onTestEnd(done, { retry: 0 });
-    clock += 41_500;
-    reporter.onEnd({ status: 'interrupted' });
-    assert.equal(output.join(''), '\nStill running when the run ended (interrupted): 1\n'
-        + '  [firefox] › a.spec.mjs:20 › hangs on a fetch (running 42.0s)\n');
-    assert.equal(host.listenerCount('SIGTERM'), 0, 'the run is over: SIGTERM gets its default again');
-    output.length = 0;
-    reporter.onTestEnd(stuck, { retry: 0 });
-    reporter.onEnd({ status: 'passed' });
-    assert.deepEqual(output, [], 'a run where every test ended prints nothing');
-});
-
-test('on the first SIGTERM the reporter prints the running tests and hands over to Playwright\'s SIGINT', () => {
-    const output = [];
-    const host = fakeHost();
-    const reporter = new RunningTestsReporter({ now: () => 0, write: text => output.push(text), host });
-    reporter.onBegin({ rootDir: '/repo/tests/browser' });
-    reporter.onTestBegin(spec('2', 'hangs on a fetch', 20), { retry: 0 });
-    host.emit('SIGTERM');
-    assert.match(output.join(''), /Still running when the run ended \(SIGTERM\): 1\n {2}\[firefox\] › a\.spec\.mjs:20 › hangs on a fetch/);
-    assert.deepEqual(host.signals, [[4242, 'SIGINT']], 'Playwright\'s own interrupt ends the run and writes the blob');
-    assert.equal(host.listenerCount('SIGTERM'), 0, 'a second SIGTERM kills the process as usual');
-});

tests/vendor/ci-workflow.test.mjs

@@ -247,26 +247,6 @@ test('browser job timeouts keep a real margin over measured runs', () => {
     }
 });
 
-// A hang (#425) must end inside the test step, before the job limit, so the log and the always()
-// uploads survive: the step's timeout-minutes < the job's.
-const BROWSER_TEST_STEP = /npm run --prefix tools\/vendor test:(workflows|coverage)/;
-
-test('each browser test step stops itself before its job limit and its traces upload anyway', () => {
-    for (const id of browserJobIds) {
-        const body = allJobs.get(id);
-        const jobMinutes = Number(/^ {4}timeout-minutes: (\d+)$/m.exec(body)[1]);
-        const jobSteps = steps(body);
-        const testAt = jobSteps.findIndex(step => BROWSER_TEST_STEP.test(step));
-        const testStep = jobSteps[testAt];
-        const stepMinutes = Number(/^ {8}timeout-minutes: (\d+)$/m.exec(testStep)?.[1]);
-        assert.ok(stepMinutes > 0, `${id}: the test step sets its own timeout-minutes`);
-        assert.ok(jobMinutes - stepMinutes >= 2, `${id}: the step limit leaves time for setup and the uploads`);
-        const upload = jobSteps.slice(testAt + 1).find(step => /^ {10}path: tools\/vendor\/test-results\/$/m.test(step));
-        assert.ok(upload, `${id} uploads tools/vendor/test-results/ (traces and blob report) after the tests`);
-        assert.match(upload, /^ {8}if: always\(\)$/m, `${id} uploads them when the step failed or timed out`);
-    }
-});
-
 // Every job is bounded (#350): a hang ends at a measured limit instead of GitHub's 6-hour default.
 const GATING_WORKFLOWS = ['test.yml', 'code-quality.yml', 'viewerjs-check.yml'];
 const BOUNDED_WORKFLOWS = [...GATING_WORKFLOWS, 'portability.yml'];

tests/vendor/frontend-coverage-cli.test.mjs

@@ -1,11 +1,9 @@
 import test from 'node:test';
 import assert from 'node:assert/strict';
-import { existsSync, mkdtempSync, mkdirSync, readFileSync, rmSync, writeFileSync } from 'node:fs';
-import { EventEmitter } from 'node:events';
-import { setTimeout as delay } from 'node:timers/promises';
+import { existsSync, mkdtempSync, mkdirSync, rmSync, writeFileSync } from 'node:fs';
 import { tmpdir } from 'node:os';
 import { join } from 'node:path';
-import { plan, runCoverage, runNode } from '../../tools/vendor/frontend-coverage.mjs';
+import { plan, runCoverage } from '../../tools/vendor/frontend-coverage.mjs';
 
 const steps = argv => plan(argv).map(({ step, ...options }) => (Object.keys(options).length ? { step, ...options } : step));
 
@@ -93,46 +91,3 @@ test('shard 1 runs the node units into the shared raw dir, then the viewer suite
     assert.ok(calls[1].args.includes(join(paths.tools, 'playwright.config.mjs')));
     assert.deepEqual(calls[2].args.slice(-2), ['--shard', '1/3']);
 });
-
-// #425: npm and a CI step timeout signal only frontend-coverage.mjs; its running child must get it.
-function hostWithSignals() {
-    return new EventEmitter();
-}
-
-test('runNode resolves on exit 0, rejects with the exit code otherwise and leaves no signal listener', async () => {
-    const host = hostWithSignals();
-    await runNode(['-e', 'process.exit(0)'], {}, { host });
-    await assert.rejects(runNode(['-e', 'process.exit(3)'], {}, { host }), /Command failed \(3\): -e process\.exit\(3\)/);
-    assert.equal(host.listenerCount('SIGTERM') + host.listenerCount('SIGINT'), 0);
-});
-
-test('runNode forwards SIGTERM to the running child, which can report before it exits', async t => {
-    const root = mkdtempSync(join(tmpdir(), 'pm-coverage-signal-'));
-    t.after(() => rmSync(root, { recursive: true, force: true }));
-    const ready = join(root, 'ready');
-    const seen = join(root, 'seen');
-    const child = `const fs = require('node:fs');
-process.on('SIGTERM', () => { fs.writeFileSync(${JSON.stringify(seen)}, 'SIGTERM'); process.exit(7); });
-fs.writeFileSync(${JSON.stringify(ready)}, ''); setInterval(() => {}, 1000);`;
-    const host = hostWithSignals();
-    const running = runNode(['-e', child], {}, { host });
-    while (!existsSync(ready)) await delay(20);
-    host.emit('SIGTERM');
-    await assert.rejects(running, /Command failed \(7\)/);
-    assert.equal(readFileSync(seen, 'utf8'), 'SIGTERM', 'the child handled the forwarded signal');
-    assert.equal(host.listenerCount('SIGTERM'), 0);
-});
-
-test('runNode forwards SIGINT and starts the child in its own process group', async () => {
-    const host = hostWithSignals();
-    const kills = [];
-    let options;
-    const fake = new EventEmitter();
-    fake.kill = signal => { kills.push(signal); queueMicrotask(() => fake.emit('exit', null, signal)); };
-    const running = runNode(['x.mjs'], {}, { host, spawnChild: (command, args, spawnOptions) => { options = spawnOptions; return fake; } });
-    assert.equal(options.detached, true, 'a group-wide signal reaches the child only through forwarding, once');
-    host.emit('SIGINT');
-    await assert.rejects(running, /Command failed \(null\): x\.mjs/);
-    assert.deepEqual(kills, ['SIGINT']);
-    assert.equal(host.listenerCount('SIGINT'), 0);
-});

tools/vendor/browser-coverage.mjs

@@ -12,10 +12,7 @@ export async function startCoverage(page, browserName) {
 export async function saveCoverage(page, browserName) {
     if (!process.env.PM_JS_COVERAGE || browserName !== 'chromium') return;
     const entries = await page.coverage.stopJSCoverage();
-    // The source is left out (#432): c8 reads it from the mapped file on disk, and repeating every script's text in every
-    // raw file made the coverage merge run out of memory.
-    const result = mapBrowserCoverage(entries, { urlPrefix: '/prompt_manager/js/', sourceRoot: join(repositoryRoot, 'web/js') })
-        .map(({ source: _source, ...entry }) => entry);
+    const result = mapBrowserCoverage(entries, { urlPrefix: '/prompt_manager/js/', sourceRoot: join(repositoryRoot, 'web/js') });
     mkdirSync(process.env.PM_JS_COVERAGE, { recursive: true });
     writeFileSync(join(process.env.PM_JS_COVERAGE, `browser-${randomUUID()}.json`), JSON.stringify({ result }));
 }

tools/vendor/frontend-coverage.mjs

@@ -1,7 +1,7 @@
 import { existsSync, readFileSync, readdirSync, mkdirSync, rmSync, writeFileSync } from 'node:fs';
 import { dirname, join, relative } from 'node:path';
 import { fileURLToPath, pathToFileURL } from 'node:url';
-import { spawn } from 'node:child_process';
+import { spawnSync } from 'node:child_process';
 import { repositoryRoot } from './vendor-viewerjs.mjs';
 
 import { discoverSources, checkCoverage } from '@comfyassets/toolkit/testing/coverage';
@@ -10,27 +10,10 @@ const metrics = ['lines', 'branches', 'functions', 'statements'];
 const SHARD = /^([1-9]\d*)\/([1-9]\d*)$/;
 const USAGE = 'usage: frontend-coverage.mjs [--update-baseline] | --shard I/N | --merge-only [--update-baseline]';
 
-const FORWARDED_SIGNALS = ['SIGTERM', 'SIGINT'];
-
-// Runs one step's node child and waits for it. npm and a CI step timeout signal only this process,
-// so SIGTERM and SIGINT are forwarded to the running child (#425): Playwright then reports the tests
-// still running and writes its blob. The child gets its own process group, so a signal sent to the
-// whole group (Ctrl-C, `timeout`) still reaches it exactly once, through this forwarding.
-export function runNode(args, env = {}, { spawnChild = spawn, host = process } = {}) {
-    return new Promise((resolve, reject) => {
-        const child = spawnChild(process.execPath, args, { cwd: repositoryRoot, stdio: 'inherit',
-            env: { ...process.env, ...env }, detached: true });
-        const forward = signal => () => child.kill(signal);
-        const handlers = FORWARDED_SIGNALS.map(signal => [signal, forward(signal)]);
-        for (const [signal, handler] of handlers) host.on(signal, handler);
-        const done = () => { for (const [signal, handler] of handlers) host.removeListener(signal, handler); };
-        child.once('error', error => { done(); reject(error); });
-        child.once('exit', code => {
-            done();
-            if (code === 0) resolve();
-            else reject(new Error(`Command failed (${code}): ${args.join(' ')}`));
-        });
-    });
+function runNode(args, env = {}) {
+    const result = spawnSync(process.execPath, args, { cwd: repositoryRoot, stdio: 'inherit',
+        env: { ...process.env, ...env } });
+    if (result.status !== 0) throw new Error(`Command failed (${result.status}): ${args.join(' ')}`);
 }
 
 function defaultPaths() {
@@ -129,17 +112,17 @@ export async function runCoverage({ argv = process.argv.slice(2), run = runNode,
         'node-units'() {
             const tests = readdirSync(join(root, 'tests/js')).filter(file => file.endsWith('.test.js'))
                 .map(file => `tests/js/${file}`);
-            return run(['--test', ...tests], { NODE_V8_COVERAGE: raw });
+            run(['--test', ...tests], { NODE_V8_COVERAGE: raw });
         },
         viewer() {
-            return run([playwright, 'test', '--config', join(tools, 'playwright.config.mjs')]);
+            run([playwright, 'test', '--config', join(tools, 'playwright.config.mjs')]);
         },
         workflows({ shard }) {
-            return run([playwright, 'test', '--config', join(tools, 'playwright.workflows.config.mjs'),
+            run([playwright, 'test', '--config', join(tools, 'playwright.workflows.config.mjs'),
                 '--project', 'chromium', '--project', 'touch', ...(shard ? ['--shard', shard] : [])], { PM_JS_COVERAGE: raw });
         },
         report() {
-            return run([join(tools, 'node_modules/c8/bin/c8.js'), 'report', '--all', '--src', sourceRoot,
+            run([join(tools, 'node_modules/c8/bin/c8.js'), 'report', '--all', '--src', sourceRoot,
                 '--include', 'web/js/**/*.js', '--include', 'web/js/**/*.mjs', '--temp-directory', raw, '--reports-dir', reportRoot,
                 '--reporter', 'text', '--reporter', 'json-summary', '--reporter', 'html']);
         },

tools/vendor/playwright.config.mjs

@@ -1,5 +1,4 @@
 import { defineConfig } from '@playwright/test';
-import { reporters } from './test-workers.mjs';
 
 export default defineConfig({
     testDir: './tests',
@@ -9,7 +8,7 @@ export default defineConfig({
     workers: 2,
     forbidOnly: Boolean(process.env.CI),
     retries: process.env.CI ? 1 : 0,
-    reporter: reporters({ name: 'viewer' }),
+    reporter: 'list',
     use: { browserName: 'chromium', headless: true, trace: 'retain-on-failure' },
     projects: [
         { name: 'desktop', use: { viewport: { width: 1280, height: 800 } } },

tools/vendor/playwright.workflows.config.mjs

@@ -1,5 +1,5 @@
 import { defineConfig, devices } from '@playwright/test';
-import { reporters, workflowWorkers } from './test-workers.mjs';
+import { workflowWorkers } from './test-workers.mjs';
 
 // No global webServer: tests/browser/fixtures.mjs starts one server per worker
 // on an OS-chosen port. Files run in parallel; tests inside a file keep their order.
@@ -11,7 +11,7 @@ export default defineConfig({
     fullyParallel: false,
     forbidOnly: Boolean(process.env.CI),
     retries: 0,
-    reporter: reporters({ name: 'workflows' }),
+    reporter: 'list',
     use: { trace: 'retain-on-failure', screenshot: 'only-on-failure' },
     projects: [
         { name: 'chromium', outputDir: './test-results/workflows/chromium', use: { browserName: 'chromium' } },

tools/vendor/running-tests-reporter.mjs

@@ -1,58 +0,0 @@
-import { writeSync } from 'node:fs';
-import { relative } from 'node:path';
-
-// Names the tests still running when a run is cut off (#425). A browser test step that reaches its
-// timeout-minutes gets SIGTERM, which ends Playwright at once: no reporter's onEnd runs, so neither
-// `list` nor the blob report says what was running. On the first SIGTERM this reporter prints every
-// started test that has not ended, then turns the signal into SIGINT, Playwright's own interrupt,
-// which stops the workers, ends the run as interrupted (non-zero exit) and writes the blob report.
-// A second SIGTERM gets the default behaviour: the process dies.
-export default class RunningTestsReporter {
-    constructor({ now = () => Date.now(), write = text => writeSync(1, text), host = process } = {}) {
-        this.now = now;
-        this.write = write;
-        this.host = host;
-        this.rootDir = host.cwd();
-        this.running = new Map();
-        this.onSigterm = () => {
-            this.host.removeListener('SIGTERM', this.onSigterm);
-            this.report('SIGTERM');
-            this.host.kill(this.host.pid, 'SIGINT');
-        };
-    }
-
-    printsToStdio() {
-        return false;
-    }
-
-    onBegin(config) {
-        this.rootDir = config.rootDir;
-        this.host.on('SIGTERM', this.onSigterm);
-    }
-
-    onTestBegin(test, result) {
-        this.running.set(`${test.id}#${result.retry}`, { test, startedAt: this.now() });
-    }
-
-    onTestEnd(test, result) {
-        this.running.delete(`${test.id}#${result.retry}`);
-    }
-
-    describe({ test, startedAt }) {
-        const project = test.parent?.project()?.name;
-        const where = `${relative(this.rootDir, test.location.file)}:${test.location.line}`;
-        const seconds = ((this.now() - startedAt) / 1000).toFixed(1);
-        return `${project ? `[${project}] › ` : ''}${where} › ${test.title} (running ${seconds}s)`;
-    }
-
-    report(reason) {
-        if (!this.running.size) return;
-        const lines = [...this.running.values()].map(entry => `  ${this.describe(entry)}`);
-        this.write(`\nStill running when the run ended (${reason}): ${this.running.size}\n${lines.join('\n')}\n`);
-    }
-
-    onEnd(result) {
-        this.host.removeListener('SIGTERM', this.onSigterm);
-        this.report(result.status);
-    }
-}

tools/vendor/test-workers.mjs

@@ -1,8 +1,4 @@
 import { availableParallelism } from 'node:os';
-import { fileURLToPath } from 'node:url';
-
-// Absolute, so a config that imports this one from another directory still finds it.
-const RUNNING_TESTS_REPORTER = fileURLToPath(new URL('./running-tests-reporter.mjs', import.meta.url));
 
 const MAX_LOCAL_WORKERS = 8;
 const CPUS_PER_WORKER = 4;
@@ -20,10 +16,3 @@ export function workflowWorkers({ env = process.env, cpus = availableParallelism
     if (env.CI) return 1;
     return Math.max(1, Math.min(MAX_LOCAL_WORKERS, Math.floor(cpus / CPUS_PER_WORKER)));
 }
-
-// Under CI, running-tests-reporter.mjs names the tests a step timeout's signal cut off (`list`
-// cannot: they never end), and a blob report beside the traces is uploaded with them.
-export function reporters({ env = process.env, name } = {}) {
-    if (!env.CI) return 'list';
-    return [['list'], [RUNNING_TESTS_REPORTER], ['blob', { outputDir: `./test-results/blob/${name}` }]];
-}

web/js/workspace/image-tagging-state.mjs

@@ -203,48 +203,17 @@ async function readDefaults(api, signal) {
 }
 
 export const UNAVAILABLE_HINT = 'Download it in System › Auto-tagging.';
-const nonEmpty = value => typeof value === 'string' && value.trim() !== '';
-const joined = names => (names.length > 1 ? `${names.slice(0, -1).join(', ')} and ${names.at(-1)}` : names.join(''));
-
-/** The pip names a `/autotag/models` entry says its backend cannot import (#424); only non-empty strings count. */
-export const missingPackages = entry => (object(entry) && Array.isArray(entry.missing_packages)
-    ? entry.missing_packages.filter(nonEmpty) : []);
-
-/** `pip install …` for `entry`'s missing packages: the server's command, else built from the names; '' when none. */
-export function installCommand(entry) {
-    const missing = missingPackages(entry);
-    if (!missing.length) return '';
-    return nonEmpty(entry.install_command) ? entry.install_command : `pip install ${missing.join(' ')}`;
-}
-
-/**
- * The server's missing-package sentence (`missing_packages_message`, #424) for `name`, else '' (nothing missing):
- * "<name> needs llama-cpp-python. Install it into ComfyUI's Python: pip install llama-cpp-python. <note>".
- */
-export function needsPackages(name, entry) {
-    const missing = missingPackages(entry);
-    if (!missing.length) return '';
-    const note = nonEmpty(entry.install_note) ? ` ${entry.install_note}` : '';
-    return `${name} needs ${joined(missing)}. Install ${missing.length === 1 ? 'it' : 'them'} into ComfyUI's Python: `
-        + `${installCommand(entry)}.${note}`;
-}
-
-/** "a, b and c": the missing package names as the sentences list them. */
-export const packageList = entry => joined(missingPackages(entry));
-
 /**
  * Why `model` cannot run, from the `/autotag/models` status (the server's own `model-unavailable` sentence), else ''
- * (ready, or the status is unknown: the job then reports a missing model itself). Not downloaded is named first, then
- * a backend package that cannot be imported (#424).
+ * (downloaded, or the status is unknown: the job then reports a missing model itself).
  */
 export function modelUnavailable(models, model) {
     const option = modelOf(model);
     requireValue(option, 'Unknown tagging model');
     const status = object(models) && object(models[model]) ? models[model] : null;
-    if (!status) return '';
-    const fallback = option.label.split(' · ')[0];
-    if (status.downloaded === false) return `${nonEmpty(status.name) ? status.name : fallback} is not downloaded. ${UNAVAILABLE_HINT}`;
-    return needsPackages(nonEmpty(status.label) ? status.label : fallback.replace(' (Recommended)', ''), status);
+    if (!status || status.downloaded !== false) return '';
+    const name = typeof status.name === 'string' && status.name.trim() ? status.name : option.label.split(' · ')[0];
+    return `${name} is not downloaded. ${UNAVAILABLE_HINT}`;
 }
 
 function initialState(source, preset) {

web/js/workspace/system-tagging.mjs

@@ -29,7 +29,7 @@ import { HOST_UNAVAILABLE } from './system-appearance.mjs';
 import { openCloseOnlyReview, openReviewDialog } from './workspace-dialogs.mjs';
 import { BACKUP_COPY, backupText, holding, reviewRefusal } from './maintenance-review.mjs';
 import { busyToast, downloadDatabaseBackup } from './activity-scan.mjs';
-import { MODEL_OPTIONS, installCommand, missingPackages, needsPackages, packageList } from './image-tagging-state.mjs';
+import { MODEL_OPTIONS } from './image-tagging-state.mjs';
 import { openImageTagging } from './image-tagging.mjs';
 import { selectedImage } from './images.mjs';
 import { NO_SELECTION } from './vocabulary.mjs';
@@ -80,7 +80,6 @@ export const STATUS_COPY = Object.freeze({
     loaded: 'Downloaded and loaded.',
     partial: 'Partly downloaded. Download again to finish.',
     missing: size => `Not downloaded. Download size ${size}.`,
-    needs: (names, command, note) => `Downloaded. Needs ${names}: ${command}.${typeof note === 'string' && note.trim() ? ` ${note}` : ''}`,
 });
 
 /** The messages that name a setting the section cannot use (the server's own wording). */
@@ -141,21 +140,15 @@ export function modelOptions(models) {
 
 /**
  * D132: the Tagging model description for `status` (`{phase: loading|loaded|failed, models}`) and the chosen `model`.
- * GGUF with only one of its two files on disk is partly downloaded. A backend package the server cannot import (#424)
- * turns "Downloaded" into "Downloaded. Needs <pkg>: pip install <pkg>." and adds "Also needs <pkg>." otherwise.
+ * GGUF with only one of its two files on disk is partly downloaded.
  */
 export function modelDescription(status, model) {
     if (status?.phase === 'loading') return STATUS_COPY.loading;
     const entry = status?.models?.[model];
     if (status?.phase !== 'loaded' || !object(entry)) return STATUS_COPY.failed;
-    // #424: a backend package that cannot be imported; a model on disk without it never reads as ready.
-    const needs = missingPackages(entry).length ? packageList(entry) : '';
-    if (entry.downloaded === true) {
-        if (needs) return STATUS_COPY.needs(needs, installCommand(entry), entry.install_note);
-        return entry.loaded === true ? STATUS_COPY.loaded : STATUS_COPY.downloaded;
-    }
-    const files = partlyDownloaded(model, entry) ? STATUS_COPY.partial : STATUS_COPY.missing(modelSize(model, entry));
-    return needs ? `${files} Also needs ${needs}.` : files;
+    if (entry.downloaded === true) return entry.loaded === true ? STATUS_COPY.loaded : STATUS_COPY.downloaded;
+    if (partlyDownloaded(model, entry)) return STATUS_COPY.partial;
+    return STATUS_COPY.missing(modelSize(model, entry));
 }
 
 /** GGUF with only one of its two files on disk (a download that did not finish). */
@@ -323,7 +316,6 @@ export function diskShortNote(disk) {
 export function batchCloseNote(plan) {
     if (plan.review_required === true) return REPLACE_NOTE;
     if (plan.model?.downloaded === false) return notDownloaded(modelLabel(plan.model.type, plan.model));
-    if (missingPackages(plan.model).length) return needsPackages(modelLabel(plan.model.type, plan.model), plan.model);
     if (plan.disk?.sufficient === false) return diskShortNote(plan.disk);
     if (!Number.isSafeInteger(plan.images) || plan.images === 0) return NO_IMAGES;
     if (plan.to_tag === 0) return NOTHING_TO_TAG;
@@ -492,9 +484,8 @@ export function mountTagging(container, { api, activity, scope, drafts, notify =
         unload.disabled = !(status.phase === 'loaded' && status.loadedType);
         if (review.textContent === 'Reviewing…') return;
         const batchProblem = known() ? draftProblem(values, { limit: false }) : unknown;
-        const label = modelLabel(values.autotag_model_type, entry);
-        setAvailable(review, entry?.downloaded === false ? notDownloaded(label)
-            : needsPackages(label, entry) || batchProblem?.message);
+        setAvailable(review, entry?.downloaded === false ? notDownloaded(modelLabel(values.autotag_model_type, entry))
+            : batchProblem?.message);
     };
 
     let reads = 0;