Populate extra artists for discogs (#6509)

## Discogs: Populate multi-value contributor fields from artist roles

Fixes: #6380

This PR extends the Discogs plugin to properly populate beets'
`remixers`, `lyricists`, `composers`, and `arrangers` fields from
Discogs artist role credits.

### What changed

**`beetsplug/discogs/states.py`** — Core logic change in `ValidArtist`
and `ArtistState`:

- The `is_feat: bool` field on `ValidArtist` is replaced with `role:
str`, preserving the raw Discogs role string rather than discarding it
after a single boolean check.
- A new `main_artists` property filters to artists with no role or a
featuring role — this replaces the previous filtering that happened at
parse time, so `valid_artists` now includes _all_ artists regardless of
role.
- `artists`, `artists_credit`, and `artists_ids` are updated to source
from `main_artists` instead of `valid_artists`, ensuring non-primary
contributors (e.g. composers, arrangers) no longer appear in artist
identity fields.
- New properties — `lyricists`, `arrangers`, `remixers`, `composers` —
derive their values from `valid_artists` by substring-matching on the
`role` field (e.g. `"lyrics"`, `"producer"`, `"remix"`, `"written-by"`).

**`beetsplug/discogs/types.py`** — `ArtistInfo` typed dict gains four
optional fields: `arrangers`, `composers`, `remixers`, `lyricists`.

### Test changes

- `test_anv` is refactored from a flat parametrised function into a
`TestAnv` class with a shared `album_info` fixture, splitting the
assertions across focused test methods per field group.
- `test_parse_featured_artists` gains assertions for `artists_ids` and
`composers`.
- A new `test_parse_extraartist_roles` test covers role-to-field mapping
end-to-end for all four contributor types.

### Impact

Discogs imports now populate contributor fields that were previously
only filled by the MusicBrainz plugin.

Author: snejus

.github/copilot-instructions.md

@@ -20,3 +20,23 @@ Core grug beliefs to apply when reviewing:
 - Simple APIs good. Layered APIs ok. Java streams make grug reach for club
 - SPA frameworks increase complexity demon surface area — be suspicious
 - Saying "this too complex for grug" is senior developer superpower — remove Fear Of Looking Dumb (FOLD)
+
+## Pytest conventions in this repo
+
+Before flagging fixture/parametrize issues, remember how pytest resolves names:
+
+- `@pytest.mark.parametrize("foo,bar", [...])` makes `foo` and `bar` behave like
+  pseudo-fixtures for the entire test call. Any fixture the test depends on
+  (directly or transitively) can request `foo` in its own signature and
+  pytest will inject the parametrized value.
+- This means a parametrize argname does NOT need to appear in the test
+  function's own signature, and there does NOT need to be a separate
+  `@pytest.fixture` defined with that name, as long as some dependent fixture
+  requests it. `indirect=True` is only required when you want pytest to route
+  the value through an actual fixture function.
+- Concretely, in `test/plugins/test_discogs.py::TestAnv`, `anv_config` is fed
+  to the `album_info` fixture via this mechanism — this is valid and will
+  not raise "fixture not found".
+
+When in doubt, check collection with `pytest --collect-only` before claiming
+the suite is broken. grug not bark if tests actually pass.

beetsplug/discogs/states.py

@@ -51,15 +51,15 @@ class ValidArtist(NamedTuple):
         """A normalized, render-ready artist entry extracted from Discogs data.
 
         Instances represent the subset of Discogs artist information needed for
-        tagging, including the join token following the artist and whether the
-        entry is considered a featured appearance.
+        tagging, including the join token following the artist and the
+        lowercased Discogs role string (e.g. "featuring", "written-by", "remix")
         """
 
         id: str
         name: str
         credit: str
         join: str
-        is_feat: bool
+        role: str
 
         def get_artist(self, property_name: str) -> str:
             """Return the requested display field with its trailing join token.
@@ -101,7 +101,6 @@ def valid_artists(self) -> list[ValidArtist]:
         - substituting the configured 'Various Artists' name when Discogs uses
           'Various'
         - choosing between name and ANV according to plugin settings
-        - excluding non-empty roles unless they indicate a featured appearance
         - capturing join tokens so the original credit formatting is preserved
         """
         va_name = config["va_name"].as_str()
@@ -111,23 +110,26 @@ def valid_artists(self) -> list[ValidArtist]:
                 self.strip_disambiguation(anv if self.use_anv else name),
                 self.strip_disambiguation(anv if self.use_credit_anv else name),
                 a["join"].strip(),
-                is_feat,
+                a["role"].lower(),
             )
             for a in self.raw_artists
             if (
                 (name := va_name if a["name"] == "Various" else a["name"])
                 and (anv := a["anv"] or name)
-                and (
-                    (is_feat := ("featuring" in a["role"].lower()))
-                    or not a["role"]
-                )
             )
         ]
 
+    @property
+    def main_artists(self) -> list[ValidArtist]:
+        """Return the per-artist display names used for the 'artist' field."""
+        return [
+            a for a in self.valid_artists if not a.role or "featuring" in a.role
+        ]
+
     @property
     def artists_ids(self) -> list[str]:
-        """Return Discogs artist IDs for all valid artists, preserving order."""
-        return [a.id for a in self.valid_artists]
+        """Return Discogs artist IDs for the main artists, preserving order."""
+        return [a.id for a in self.main_artists]
 
     @property
     def artist_id(self) -> str:
@@ -137,12 +139,12 @@ def artist_id(self) -> str:
     @property
     def artists(self) -> list[str]:
         """Return the per-artist display names used for the 'artist' field."""
-        return [a.name for a in self.valid_artists]
+        return [a.name for a in self.main_artists]
 
     @property
     def artists_credit(self) -> list[str]:
         """Return the per-artist display names used for the credit field."""
-        return [a.credit for a in self.valid_artists]
+        return [a.credit for a in self.main_artists]
 
     @property
     def artist(self) -> str:
@@ -154,6 +156,28 @@ def artist_credit(self) -> str:
         """Return the fully rendered artist credit string."""
         return self.join_artists("credit")
 
+    @property
+    def lyricists(self) -> list[str] | None:
+        return [
+            a.name for a in self.valid_artists if "lyrics" in a.role
+        ] or None
+
+    @property
+    def arrangers(self) -> list[str] | None:
+        return [
+            a.name for a in self.valid_artists if "arrang" in a.role
+        ] or None
+
+    @property
+    def remixers(self) -> list[str] | None:
+        return [a.name for a in self.valid_artists if "remix" in a.role] or None
+
+    @property
+    def composers(self) -> list[str] | None:
+        return [
+            a.name for a in self.valid_artists if "written-by" in a.role
+        ] or None
+
     def join_artists(self, property_name: str) -> str:
         """Render a single artist string with join phrases and featured artists.
 
@@ -162,8 +186,8 @@ def join_artists(self, property_name: str) -> str:
         Discogs order while keeping featured credits separate from the main
         artist string.
         """
-        non_featured = [a for a in self.valid_artists if not a.is_feat]
-        featured = [a for a in self.valid_artists if a.is_feat]
+        non_featured = [a for a in self.main_artists if not a.role]
+        featured = [a for a in self.main_artists if "featuring" in a.role]
 
         artist = "".join(a.get_artist(property_name) for a in non_featured)
         if featured:

beetsplug/discogs/types.py

@@ -55,6 +55,10 @@ class ArtistInfo(TypedDict):
     artists_credit: list[str]
     artist_id: str
     artists_ids: list[str]
+    arrangers: list[str] | None
+    composers: list[str] | None
+    remixers: list[str] | None
+    lyricists: list[str] | None
 
 
 class TracklistInfo(TypedDict):

docs/changelog.rst

@@ -28,6 +28,9 @@ New features
 
 - :doc:`plugins/inline`: Add access to the ``album`` or ``item`` object as
   ``db_obj`` in inline fields.
+- :doc:`plugins/discogs`: Import Discogs remixer, lyricist, composer, and
+  arranger credits into the multi-value ``remixers``, ``lyricists``,
+  ``composers``, and ``arrangers`` fields. :bug:`6380`
 
 Bug fixes
 ~~~~~~~~~

docs/plugins/discogs.rst

@@ -204,6 +204,20 @@ Default
                artist: no
                album_artist: no
 
+Contributor credits
+~~~~~~~~~~~~~~~~~~~
+
+When Discogs provides artist roles on a track, beets uses them to separate main
+artists from other credited contributors. Main artist fields such as ``artist``,
+``artists``, ``artist_credit``, ``artists_credit``, ``artist_id``, and
+``artists_ids`` keep the primary artist credits, while featured artists from
+track roles are appended using :conf:`plugins.discogs:featured_string`.
+
+Discogs contributor roles are also imported into beets' multi-value performer
+fields when available. This includes remixer, lyricist, composer, and arranger
+credits, which populate ``remixers``, ``lyricists``, ``composers``, and
+``arrangers`` respectively.
+
 .. include:: ./shared_metadata_source_config.rst
 
 .. _discogs guidelines: https://support.discogs.com/hc/en-us/articles/360005055373-Database-Guidelines-12-Tracklisting#Index_Tracks_And_Headings