Auto-tagging only the artist field of imported tracks without moving or copying

[nadimz]

I have a few compilation albums with incorrectly tagged artists (e.g., Beatles instead of The Beatles).
Is there a way to auto-tag only a specific field, in this case, the artist field in all tracks in an already imported album?

I tried to re-import in singleton mode pointing to the compilation album path but it changes the album name as well.
If it's possible to specify which fields not to update, that would be helpful as well.

My config file:

plugins: inline scrub fetchart  musicbrainz discogs info

directory: /shared/music/main
library: /shared/music/main-library.db

import:
  move: yes

item_fields:
  multidisc: 1 if disctotal > 1 else 0

paths:
  default: $albumartist/$album%aunique{}/%if{$multidisc,$disc-}$track - $title
  singleton: Non-Album/$artist/$title
  comp: Compilations/$album%aunique{}/$track - $title

[0xshubhs]

No per-field import mode, the importer is all-or-nothing. Two options.

If the album has MusicBrainz IDs:

beet mbsync --nomove album:'Album Name'

Skips the importer, but still refreshes every field it knows.

For one field only, don't auto-tag at all:

beet modify -M artist:Beatles artist='The Beatles'

-M/--nomove (modify.py:181) matters because changing artist re-evaluates your path templates and beets will relocate the files without it. -W also skips writing tags to disk.

Your comp: template only uses $album so nothing would move here anyway, but keep -M as a habit.

[nadimz]

Thanks for the response.

The albums don't have MB IDs. With modify, I need to manually review all incorrectly tagged artists and call modify on each . I hoped I could avoid that. There are many tracks with slightly incorrect artist name.

What ideally I'd like to achieve is:

• Query MusicBrainz for tracks using artist and title
• Modify artist tag to match MusicBrainz result if a match is found (say 90% confidence or higher)
• Log the track otherwise

I understand why it's not possible to that beet. It doesn't really fit the workflow. I could try to write a script for this.

[aribradshaw]

You can do this safely as a small local plugin. I would not treat a string-similarity percentage as a confidence probability. Beets already has a weighted matcher and a Recommendation.strong threshold, so I would reuse that and only change artist after a strong MusicBrainz result.

This is a dry run unless --apply is supplied:

from beets import ui
from beets.autotag import Recommendation, Source, tag_item
from beets.plugins import BeetsPlugin


class ArtistOnlyPlugin(BeetsPlugin):
    def commands(self):
        cmd = ui.Subcommand(
            "artistonly",
            help="propose MusicBrainz artist corrections without moving files",
        )
        cmd.parser.add_option(
            "--apply",
            action="store_true",
            default=False,
            help="apply strong MusicBrainz matches; otherwise dry-run",
        )
        cmd.parser.add_option("-w", "--write", action="store_true", default=None)
        cmd.parser.add_option("-W", "--nowrite", action="store_false", dest="write")
        cmd.func = self.command
        return [cmd]

    def command(self, lib, opts, args):
        write = ui.should_write(opts.write)
        for item in lib.items(args):
            proposal = tag_item(Source.from_item(item))
            if not proposal.candidates or proposal.recommendation != Recommendation.strong:
                self._log.info("SKIP (no strong match): {} - {}", item.artist, item.title)
                continue

            match = proposal.candidates[0]
            if match.info.data_source != "MusicBrainz":
                self._log.info(
                    "SKIP (best source is {}): {} - {}",
                    match.info.data_source,
                    item.artist,
                    item.title,
                )
                continue

            new_artist = match.info.artist
            if not new_artist or new_artist == item.artist:
                continue

            self._log.info("{} - {}  =>  {}", item.artist, item.title, new_artist)
            if opts.apply:
                item.artist = new_artist
                if write:
                    item.try_write()
                item.store()

Save it as artistonly.py in a directory listed under pluginpath, then add artistonly to plugins.

# Preview one compilation first
beet artistonly album:"Album Name"

# Update the database and file tags
beet artistonly --apply album:"Album Name"

# Update only the database, not file tags
beet artistonly --apply -W album:"Album Name"

This never calls move(), so it will not relocate files. With your current configuration, tag_item searches both MusicBrainz and Discogs; the explicit source check above skips a track unless the winning strong candidate is from MusicBrainz. The default strong threshold is much stricter than a nominal 90% string match, but it is still not infallible for ambiguous titles, so I would review a dry run and back up the library database before the first apply.

[nadimz]

Awesome. That's exactly what I was looking for.

I played around with the strong threshold value in a few dry runs and got the best results with:

match:
  strong_rec_thresh: 0.15

This tags most of the tracks. I can review whatever it misses and tag manually later.

I had to do a small change in your code because the latest version of beets installed with pip doesn't have #6681 integrated yet. I also decided to apply track and md_artistid in addition to artist tag.

Thanks!

[nadimz]

Update for anyone trying this. Don't update mb_artistid. It will be written to the database but a beet write will not persist it in the tags. Seems related to #5914. This means that every time beet write is executed, it will try to write mb_artistid to the track's tags with no luck. I had to write another small plugin to cleanup the database.

Anyway, @aribradshaw's code above is safe to use as is.