Show first-release year in candidate list with a Settings toggle

Author: frznn

discvault/config.py

@@ -67,6 +67,7 @@ class Config:
     log_to_file: bool = False
     blank_redundant_track_artist: bool = True
     dedupe_equivalent_candidates: bool = True
+    prefer_first_release_year: bool = True
     manual_src_musicbrainz: bool = True
     manual_src_discogs: bool = True
     use_local_cddb_cache: bool = True
@@ -162,6 +163,10 @@ def _src_default(key: str, default: bool) -> bool:
             dv.get("dedupe_equivalent_candidates"),
             cfg.dedupe_equivalent_candidates,
         )
+        cfg.prefer_first_release_year = _as_bool(
+            dv.get("prefer_first_release_year"),
+            cfg.prefer_first_release_year,
+        )
         cfg.manual_src_musicbrainz = _as_bool(
             dv.get("manual_src_musicbrainz"),
             cfg.manual_src_musicbrainz,
@@ -230,6 +235,7 @@ def save(self) -> None:
             f"log_to_file = {str(self.log_to_file).lower()}",
             f"blank_redundant_track_artist = {str(self.blank_redundant_track_artist).lower()}",
             f"dedupe_equivalent_candidates = {str(self.dedupe_equivalent_candidates).lower()}",
+            f"prefer_first_release_year = {str(self.prefer_first_release_year).lower()}",
             f"manual_src_musicbrainz = {str(self.manual_src_musicbrainz).lower()}",
             f"manual_src_discogs = {str(self.manual_src_discogs).lower()}",
             f"use_local_cddb_cache = {str(self.use_local_cddb_cache).lower()}",

discvault/ui/settings.py

@@ -188,6 +188,11 @@ def _rows(self) -> list:
                     "cfg-dedupe-equivalent",
                     self._cfg.dedupe_equivalent_candidates,
                 ),
+                (
+                    "Prefer first-release year",
+                    "cfg-prefer-first-release-year",
+                    self._cfg.prefer_first_release_year,
+                ),
             ),
 
             Static("Logging", classes="cfg-section-header"),
@@ -298,6 +303,7 @@ def _build_config(self) -> Config:
         cfg.log_to_file = self._check("cfg-log-to-file")
         cfg.blank_redundant_track_artist = self._check("cfg-blank-redundant-artists")
         cfg.dedupe_equivalent_candidates = self._check("cfg-dedupe-equivalent")
+        cfg.prefer_first_release_year = self._check("cfg-prefer-first-release-year")
         completion_sound = self.query_one("#cfg-completion-sound", Select).value
         if completion_sound in {"bell", "chime", "both", "off"}:
             cfg.completion_sound = completion_sound

discvault/ui/tui.py

@@ -1491,12 +1491,13 @@ def _enter_ready(self) -> None:
         self._sync_track_selection()
         table = self.query_one("#meta-table", DataTable)
         table.clear(columns=True)
-        table.add_columns("#", "Source", "Artist", "Album", "Year", "Tracks")
+        table.add_columns("#", "Source", "Artist", "Album", "First release", "Year", "Tracks")
         for i, m in enumerate(self._candidates, 1):
             self._ensure_meta_tracks(m)
             table.add_row(
                 str(i), m.source,
                 m.album_artist or "(unknown)", m.album or "(untitled)",
+                m.first_release_year or "—",
                 m.year or "—", str(m.track_count),
             )
         if self._candidates:
@@ -1556,6 +1557,12 @@ def _enter_ready(self) -> None:
             self._auto_import_url_pending = False
             self.set_timer(0, lambda: self._start_import_from_value("url", self._metadata_url))
 
+    def _year_for_input(self, m: "Metadata") -> str:
+        """Pick which year populates ``#input-year`` for a candidate."""
+        if self._cfg.prefer_first_release_year and m.first_release_year:
+            return m.first_release_year
+        return m.year or ""
+
     def _apply_candidate(self, idx: int) -> None:
         if not self._candidates or idx >= len(self._candidates):
             return
@@ -1566,7 +1573,7 @@ def _apply_candidate(self, idx: int) -> None:
         if not self._args.album:
             self.query_one("#input-album", Input).value = m.album or ""
         if not self._args.year:
-            self.query_one("#input-year", Input).value = m.year or ""
+            self.query_one("#input-year", Input).value = self._year_for_input(m)
 
         self._render_track_editor(m)
 

tests/test_config.py

@@ -190,6 +190,36 @@ def test_dedupe_equivalent_candidates_defaults_to_true_when_missing(self) -> Non
 
         self.assertTrue(cfg.dedupe_equivalent_candidates)
 
+    def test_prefer_first_release_year_round_trip(self) -> None:
+        with tempfile.TemporaryDirectory() as tmp:
+            config_path = Path(tmp) / "config.toml"
+            old = config_mod.CONFIG_PATH
+            config_mod.CONFIG_PATH = config_path
+            try:
+                cfg = config_mod.Config()
+                cfg.prefer_first_release_year = False
+                cfg.save()
+                loaded = config_mod.Config.load()
+                saved_text = config_path.read_text()
+            finally:
+                config_mod.CONFIG_PATH = old
+
+        self.assertFalse(loaded.prefer_first_release_year)
+        self.assertIn("prefer_first_release_year = false", saved_text)
+
+    def test_prefer_first_release_year_defaults_to_true_when_missing(self) -> None:
+        with tempfile.TemporaryDirectory() as tmp:
+            config_path = Path(tmp) / "config.toml"
+            config_path.write_text("[discvault]\n")
+            old = config_mod.CONFIG_PATH
+            config_mod.CONFIG_PATH = config_path
+            try:
+                cfg = config_mod.Config.load()
+            finally:
+                config_mod.CONFIG_PATH = old
+
+        self.assertTrue(cfg.prefer_first_release_year)
+
     def test_lookup_log_timings_round_trip(self) -> None:
         with tempfile.TemporaryDirectory() as tmp:
             config_path = Path(tmp) / "config.toml"

tests/test_tui.py

@@ -1106,5 +1106,60 @@ def test_ensure_meta_tracks_omits_trailing_extra_track_from_editor(self) -> None
         self.assertEqual(app._possible_extra_tracks(meta), [13])
 
 
+class YearForInputTests(unittest.TestCase):
+    def _app(self, *, prefer_first: bool) -> DiscvaultApp:
+        cfg = Config()
+        cfg.prefer_first_release_year = prefer_first
+        args = Namespace(
+            tracks=None, metadata_file=None, metadata_url=None,
+            mp3_bitrate=320, mp3_quality=2, flac_compression=8,
+            no_image=False, no_flac=False, no_mp3=False, ogg=False,
+            opus=False, alac=False, aac=False, wav=False, iso=False,
+            artist=None, album=None, year=None,
+        )
+        return DiscvaultApp(args, cfg)
+
+    def _meta(self, *, year: str = "", first: str = "") -> Metadata:
+        return Metadata(
+            source="X",
+            album_artist="Artist",
+            album="Album",
+            year=year,
+            first_release_year=first,
+        )
+
+    def test_prefer_first_with_both_years_returns_first(self) -> None:
+        app = self._app(prefer_first=True)
+        self.assertEqual(app._year_for_input(self._meta(year="2006", first="1969")), "1969")
+
+    def test_prefer_first_with_only_pressing_year_returns_pressing(self) -> None:
+        app = self._app(prefer_first=True)
+        self.assertEqual(app._year_for_input(self._meta(year="2006")), "2006")
+
+    def test_prefer_first_with_only_first_year_returns_first(self) -> None:
+        app = self._app(prefer_first=True)
+        self.assertEqual(app._year_for_input(self._meta(first="1969")), "1969")
+
+    def test_prefer_off_returns_pressing_year_even_when_first_is_set(self) -> None:
+        app = self._app(prefer_first=False)
+        self.assertEqual(app._year_for_input(self._meta(year="2006", first="1969")), "2006")
+
+    def test_prefer_off_with_no_pressing_year_returns_empty_string(self) -> None:
+        app = self._app(prefer_first=False)
+        self.assertEqual(app._year_for_input(self._meta(first="1969")), "")
+
+
+class CandidateTableColumnsTests(unittest.TestCase):
+    def test_table_includes_first_release_column(self) -> None:
+        # Source-level invariant: the candidate table headers list `First release`
+        # between `Album` and `Year`. Verifying the source is enough; rendering
+        # requires an active Textual App and is exercised manually.
+        source = inspect.getsource(DiscvaultApp._enter_ready)
+        self.assertIn(
+            '"#", "Source", "Artist", "Album", "First release", "Year", "Tracks"',
+            source,
+        )
+
+
 if __name__ == "__main__":
     unittest.main()