v2.5.6

NEWS.md

@@ -6,6 +6,20 @@ width: 128px;
 border-radius: 128px;
 " />
 
+## v2.5.6
+
+- Features
+    - Filter, search, view, edit, and online tag by series years, series status,
+      and series summary. End year, status and summary are saved in Codex only,
+      not comic metadata.
+    - Browser title shows series years and a Tags button.
+    - Online tag match picker shows series and issue details to help
+      disambiguate similar covers and titles.
+- Fixes
+    - Browsing comics without embedded tags, or re-importing unchanged comics,
+      no longer rebuilds their covers and reloads the page.
+    - Searches for a universe designation no longer miss imported comics.
+
 ## v2.5.5
 
 - Features

bin/manage.py

@@ -48,6 +48,11 @@ def _discover() -> str:
 
 def main():
     """Run the server."""
+    # Python puts the script's own bin/ first on sys.path, not the root, so
+    # the project would come from whatever copy the venv installed (another
+    # worktree's editable install, say). Put the root first, as a root-level
+    # manage.py gets for free.
+    sys.path.insert(0, str(ROOT))
     # Not setdefault: its argument runs first, and _discover() raises in a
     # project with two settings modules even when the variable picks one.
     if not os.environ.get("DJANGO_SETTINGS_MODULE"):

codex/choices/choices_to_json.py

@@ -33,6 +33,7 @@
     IDENTIFIER_TYPE_BY_CODEX_NAME,
     IDENTIFIER_TYPES,
     LANGUAGES,
+    SERIES_STATUSES,
 )
 
 _DEFAULTS = MappingProxyType(
@@ -81,6 +82,7 @@
         "reader-defaults.json": READER_DEFAULTS,
         "reader-map.json": READER_CHOICES,
         "search-map.json": SEARCH_FIELDS,
+        "series-statuses.json": SERIES_STATUSES,
         "tagging-estimate.json": TAGGING_ESTIMATE,
     }
 )

codex/choices/search.py

@@ -14,6 +14,8 @@
             "month",
             "year",
             "page_count",
+            "series_end_year",
+            "series_start_year",
             "size",
             "decade",
             "volume",
@@ -114,7 +116,15 @@ def _get_fieldmap_values(*args) -> tuple:
         "review": (),
         "scan_info": ("scan",),
         "series": (),
+        "series_end_year": _get_fieldmap_values("series_end_year", "end_year"),
         "series_groups": _get_fieldmap_values("series_groups"),
+        "series_start_year": _get_fieldmap_values("series_start_year", "start_year"),
+        # Hand-written: the generator would strip the final "s" into a
+        # bogus singular.
+        "series_status": ("series-status", "seriesstatus", "status"),
+        "series_summary": _get_fieldmap_values(
+            "series_summary", "series_desc", "series_description"
+        ),
         "size": (),
         "sources": _get_fieldmap_values("sources", "id_sources"),
         "stories": ("story",),

codex/choices/tagging.py

@@ -27,6 +27,7 @@
 from comicbox.formats.metron_info.transform import MetronInfoTransform
 
 from codex.choices.reader import READER_CHOICES
+from codex.models.choices import SeriesStatusChoices
 from codex.models.identifier import IdentifierType, to_comicbox_id_type
 
 # comicbox transform per codex write-format id.
@@ -84,6 +85,13 @@ def _vuetify_choices(pairs: Iterable[tuple[str, str]]) -> tuple[MappingProxyType
     {id_type.value: to_comicbox_id_type(id_type.value) for id_type in IdentifierType}
 )
 
+# A series' publication status (Ongoing, Completed, ...). No format codex
+# writes holds it, so the editor saves it to the database only and offers
+# it under every format.
+SERIES_STATUSES = _vuetify_choices(
+    (str(label), str(value)) for value, label in SeriesStatusChoices.choices
+)
+
 
 # ---------------------------------------------------------------------------
 # Per-format field support, derived from the comicbox transforms
@@ -156,16 +164,17 @@ def _vuetify_choices(pairs: Iterable[tuple[str, str]]) -> tuple[MappingProxyType
 # Editor sub-fields comicbox stores only for some formats and which its
 # transform specs don't surface at the SPECS_TO top level (the
 # hand-maintained support data): MetronInfo's Series carries a volume
-# count, only MetronInfo's CommunityRating persists a rating count, and
-# only MetronInfo encodes a reprint's volume number (in Reprints) and
-# language (in Series/AlternativeNames). Whether a reprint row is one of
-# the series' other names is MetronInfo's too, and for the same reason:
-# ComicInfo has no reprint tag at all, since comicbox 5 reads its
-# AlternateSeries and AlternateNumber as a story arc.
+# count and a start year, only MetronInfo's CommunityRating persists a
+# rating count, and only MetronInfo encodes a reprint's volume number (in
+# Reprints) and language (in Series/AlternativeNames). Whether a reprint
+# row is one of the series' other names is MetronInfo's too, and for the
+# same reason: ComicInfo has no reprint tag at all, since comicbox 5 reads
+# its AlternateSeries and AlternateNumber as a story arc.
 _EXTRA_FORMAT_FIELDS: MappingProxyType[str, tuple[str, ...]] = MappingProxyType(
     {
         "METRON_INFO": (
             "volume_count",
+            "start_year",
             "community_rating_count",
             "reprint_volume",
             "reprint_language",

codex/librarian/onlinetag/session_state.py

@@ -215,6 +215,21 @@ def serialize_candidate(c) -> dict[str, Any]:
             # The series' ordinal volume. Metron's issue rows carry one;
             # Comic Vine's search results have no equivalent.
             "volume": getattr(summary, "volume", None),
+            # What tells apart candidates whose covers and titles read
+            # identically: a reprint volume, a foreign or a collected
+            # edition. Comic Vine fills most of these from rows it already
+            # fetched. Metron always has the start year, but gets the
+            # format, publisher and issue count only when titles collide.
+            # Absent before comicbox 5.4, and None wherever a source has
+            # nothing.
+            "series_start_year": getattr(summary, "series_start_year", None),
+            "series_publisher": getattr(summary, "series_publisher", None),
+            "series_issue_count": getattr(summary, "series_issue_count", None),
+            # Publication format, e.g. "Trade Paperback". Metron only.
+            "series_type": getattr(summary, "series_type", None),
+            # The issue's own title and one-line deck. Comic Vine only.
+            "issue_title": getattr(summary, "issue_title", None),
+            "issue_summary": getattr(summary, "issue_summary", None),
         },
         "score": float(c.score),
         # What the blended score is made of. Two candidates can read

codex/librarian/scribe/importer/const.py

@@ -56,6 +56,10 @@
 PARENT_FOLDER_FIELD_NAME = "parent_folder"
 VOLUME_COUNT_FIELD_NAME = "volume_count"
 ISSUE_COUNT_FIELD_NAME = "issue_count"
+START_YEAR_FIELD_NAME = "start_year"
+END_YEAR_FIELD_NAME = "end_year"
+STATUS_FIELD_NAME = "status"
+SUMMARY_FIELD_NAME = "summary"
 PATH_FIELD_NAME = "path"
 IDENTIFIERS_FIELD_NAME = "identifiers"
 CREDIT_PRIMARY_FIELD_NAME = "primary"
@@ -153,20 +157,25 @@ def _metron_fts_values(values: tuple) -> tuple:
 FTS_UPDATE = "fts_update"
 FTS_CREATE = "fts_create"
 FTS_EXISTING_M2MS = "fts_existing_m2ms"
-FTS_CREATED_M2MS = "fts_created_m2ms"
 FTS_UPDATED_M2MS = "fts_updated_m2ms"
 
 #######
 # M2M #
 #######
-COLLECTION_MODEL_COUNT_FIELDS: MappingProxyType[
-    type[BrowserCollectionModel], str | None
+COLLECTION_MODEL_ATTR_FIELDS: MappingProxyType[
+    type[BrowserCollectionModel], tuple[str, ...]
 ] = MappingProxyType(
     {
-        Publisher: None,
-        Imprint: None,
-        Series: VOLUME_COUNT_FIELD_NAME,
-        Volume: ISSUE_COUNT_FIELD_NAME,
+        Publisher: (),
+        Imprint: (),
+        Series: (
+            VOLUME_COUNT_FIELD_NAME,
+            START_YEAR_FIELD_NAME,
+            END_YEAR_FIELD_NAME,
+            STATUS_FIELD_NAME,
+            SUMMARY_FIELD_NAME,
+        ),
+        Volume: (ISSUE_COUNT_FIELD_NAME,),
     }
 )
 COMIC_M2M_FIELDS: tuple[ManyToManyField, ...] = cast(
@@ -201,6 +210,8 @@ def _metron_fts_values(values: tuple) -> tuple:
 REPRINT_LANGUAGE_FIELD_NAME = "language"
 # Reprints index only their series names, under their own ComicFTS column.
 ALTERNATE_SERIES_FTS_FIELD_NAME = "alternate_series"
+# The linked series' summary, indexed on each of its comics.
+SERIES_SUMMARY_FTS_FIELD_NAME = "series_summary"
 UNIVERSES_FIELD_NAME = "universes"
 NAME_FIELD_NAME = "name"
 NUMBER_TO_FIELD_NAME = "number_to"
@@ -282,7 +293,7 @@ def _metron_fts_values(values: tuple) -> tuple:
                 NAME_FIELD_NAME,
             ),
             _IDENTIFIER_RELS,
-            VOLUME_COUNT_FIELD_NAME,
+            *COLLECTION_MODEL_ATTR_FIELDS[Series],
         ),
         Volume: (
             (
@@ -293,7 +304,7 @@ def _metron_fts_values(values: tuple) -> tuple:
                 NUMBER_TO_FIELD_NAME,
             ),
             "",
-            ISSUE_COUNT_FIELD_NAME,
+            *COLLECTION_MODEL_ATTR_FIELDS[Volume],
         ),
         Folder: (
             (PATH_FIELD_NAME,),
@@ -324,23 +335,6 @@ def _metron_fts_values(values: tuple) -> tuple:
         Universe: ((NAME_FIELD_NAME,), _IDENTIFIER_RELS, DESIGNATION_FIELD_NAME),
     }
 )
-_IDENTIFIED_SELECT_RELATED = ("identifier", "identifier__source")
-MODEL_SELECT_RELATED: MappingProxyType[type[BaseModel], tuple[str, ...]] = (
-    MappingProxyType(
-        {
-            **dict.fromkeys(IDENTIFIED_MODELS, _IDENTIFIED_SELECT_RELATED),
-            Identifier: (IDENTIFIER_SOURCE_FIELD_NAME,),
-            Publisher: _IDENTIFIED_SELECT_RELATED,
-            Imprint: ("publisher",),
-            Series: ("publisher", "imprint"),
-            Volume: ("publisher", "imprint", "series"),
-            Credit: (CREDIT_PERSON_FIELD_NAME, CREDIT_ROLE_FIELD_NAME),
-            Reprint: _IDENTIFIED_SELECT_RELATED,
-            StoryArcNumber: (STORY_ARC_FIELD_NAME,),
-            Universe: _IDENTIFIED_SELECT_RELATED,
-        }
-    )
-)
 FIELD_NAME_KEYS_REL_MAP = MappingProxyType(
     {
         # ``related_model`` is typed ``type[Model] | Literal['self']

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

@@ -12,9 +12,11 @@
     BULK_UPDATE_COMIC_FIELDS_SET,
     COLLECTION_FIELD_NAMES,
     CREATE_COMICS,
+    DELETE_M2MS,
     FTS_CREATE,
     FTS_UPDATE,
     LINK_FKS,
+    LINK_M2MS,
     NON_FTS_FIELDS,
     PATH_FIELD_NAME,
     UPDATE_COMICS,
@@ -33,6 +35,10 @@
 if TYPE_CHECKING:
     from codex.models.collections import BrowserCollectionModel
 
+# What ``presave`` derives from the file and the row. An update that would
+# change none of them, the timestamp aside, writes nothing new.
+_NOOP_CHECK_FIELDS = tuple(sorted(ALWAYS_UPDATE_COMIC_FIELDS - {"updated_at"}))
+
 
 class CreateComicsImporter(CreateForeignKeyLinksImporter):
     """Create comics methods."""
@@ -66,10 +72,55 @@ def _record_moved_source_collections(
             )
             self.moved_source_collections.setdefault(model, set()).add(old_pk)
 
+    def _is_noop_update(
+        self,
+        comic: Comic,
+        md: dict,
+        link_md: dict,
+        m2m_deleted_pks: frozenset[int],
+    ) -> bool:
+        """
+        Return whether updating this comic would write nothing new.
+
+        A forced or lazy import of an unchanged comic, typically one with no
+        embedded tags, used to rewrite the row anyway: that purged and rebuilt
+        its cover and broadcast LIBRARY_CHANGED, reloading every browser. The
+        query phase has already pruned every link that is already correct, so
+        no scalar, FK or m2m change remains. If ``presave`` then derives the
+        same stat and the same values from the file on disk, the row is
+        current. A chunk that changed tag or collection rows keeps every comic
+        (see ``chunk_fks_updated``).
+        """
+        if (
+            self.chunk_fks_updated
+            or md
+            or link_md
+            or comic.path in self.task.series_attrs
+        ):
+            return False
+        if (
+            comic.path in self.metadata.get(LINK_M2MS, {})
+            or comic.pk in m2m_deleted_pks
+        ):
+            return False
+        before = tuple(getattr(comic, field_name) for field_name in _NOOP_CHECK_FIELDS)
+        comic.presave()
+        return before == tuple(
+            getattr(comic, field_name) for field_name in _NOOP_CHECK_FIELDS
+        )
+
     def _update_comic_values(
-        self, comic: Comic, update_comics: list, comic_pks: list, changed_fields: set
+        self,
+        comic: Comic,
+        update_comics: list,
+        comic_pks: list,
+        changed_fields: set,
+        m2m_deleted_pks: frozenset[int],
     ) -> None:
         md = self.metadata[UPDATE_COMICS].pop(comic.pk, {})
+        link_md = self.get_comic_fk_links(comic.pk, comic.path, for_create=False)
+        if self._is_noop_update(comic, md, link_md, m2m_deleted_pks):
+            return
         for field_name, value in md.items():
             setattr(comic, field_name, value)
         changed_fields.update(md)
@@ -82,7 +133,6 @@ def _update_comic_values(
             field_name: getattr(comic, f"{field_name}_id")
             for field_name in COLLECTION_FIELD_NAMES
         }
-        link_md = self.get_comic_fk_links(comic.pk, comic.path, for_create=False)
         changed_fields.update(link_md)
         for field_name, value in link_md.items():
             set_value = value
@@ -125,12 +175,17 @@ def update_comics(self) -> int:
             update_comics = []
             comic_pks = []
             changed_fields: set[str] = set()
+            m2m_deleted_pks = frozenset(
+                comic_pk
+                for rows in self.metadata.get(DELETE_M2MS, {}).values()
+                for comic_pk, _ in rows
+            )
             for comic in comics:
                 if self.abort_event.is_set():
                     return count
                 try:
                     self._update_comic_values(
-                        comic, update_comics, comic_pks, changed_fields
+                        comic, update_comics, comic_pks, changed_fields, m2m_deleted_pks
                     )
                 except Exception:
                     self.log.exception(f"Error preparing {comic} for update.")

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

@@ -4,6 +4,7 @@
 from types import MappingProxyType
 
 from codex.librarian.scribe.importer.const import (
+    COLLECTION_MODEL_ATTR_FIELDS,
     CREDIT_PERSON_FIELD_NAME,
     CREDIT_PRIMARY_FIELD_NAME,
     CREDIT_ROLE_FIELD_NAME,
@@ -28,7 +29,6 @@
     REPRINT_VOLUME_NUMBER_FIELD_NAME,
     SERIES_FIELD_NAME,
     STORY_ARC_FIELD_NAME,
-    VOLUME_COUNT_FIELD_NAME,
 )
 from codex.models import (
     Credit,
@@ -68,6 +68,7 @@
         {
             Universe: frozenset({"designation"}),
             Identifier: frozenset({"id_type", "key", "url"}),
+            Series: DEFAULT_NON_NULL_CHARFIELD_NAMES | {"status", "summary"},
             Comic: frozenset({"path"}),
             Volume: frozenset({}),
         }
@@ -104,7 +105,10 @@
                 IMPRINT_FIELD_NAME: Imprint,
                 NAME_FIELD_NAME: None,
             },
-            {IDENTIFIER_FIELD_NAME: Identifier, VOLUME_COUNT_FIELD_NAME: None},
+            {
+                IDENTIFIER_FIELD_NAME: Identifier,
+                **dict.fromkeys(COLLECTION_MODEL_ATTR_FIELDS[Series]),
+            },
         ),
         Volume: (
             {