5352db0a22
Sokhi: after the earlier flag fix, scans returned 0 matches — albums with embedded art but no cover.jpg were treated as fully arted and skipped, so their cover.jpg never got written. Root cause: the scan used album_has_art_on_disk (True if EITHER embedded art OR a cover.jpg exists), conflating the two. Now it checks them separately: - a local album is flagged if it lacks embedded art, OR it lacks a cover.jpg sidecar AND cover.jpg writing is enabled (metadata_enhancement.cover_art_ download — Boulder: "only scan for cover.jpgs when enabled"). - an album that has embedded art but no sidecar is fixable even when the API finds no art: the apply writes cover.jpg from the EXISTING embedded art. apply_art_to_album_files now writes the cover.jpg sidecar by extracting the album's own embedded art (new extract_embedded_art) — consistent with the files, no API call — and only falls back to download_cover_art when there's nothing embedded to extract. _fix_missing_cover_art no longer bails on a missing artwork_url when sidecar_from_embedded is set. Tests: scan flags embedded-but-no-cover.jpg (incl. when API finds nothing), still skips albums with both, still flags artless albums; apply writes cover.jpg from embedded art (no download), falls back to download when none, skips when a sidecar already exists; extract_embedded_art unit tests. 1344 cover/art/repair tests pass.
481 lines
23 KiB
Python
481 lines
23 KiB
Python
"""Missing Cover Art Filler Job — finds albums without artwork and locates art from APIs."""
|
|
|
|
import os
|
|
import re
|
|
|
|
from core.metadata.art_apply import file_has_embedded_art, folder_has_cover_sidecar
|
|
from core.library.path_resolver import resolve_library_file_path
|
|
from core.metadata_service import get_client_for_source, get_primary_source, get_source_priority
|
|
from core.repair_jobs import register_job
|
|
from core.repair_jobs.base import JobContext, JobResult, RepairJob
|
|
from utils.logging_config import get_logger
|
|
|
|
logger = get_logger("repair_job.cover_art")
|
|
|
|
# Stopwords dropped before comparing album/artist names so trivial words
|
|
# ("the", "and") don't make two different names look like a match.
|
|
_NAME_STOPWORDS = {'the', 'a', 'an', 'and', 'of', 'feat', 'ft', 'featuring'}
|
|
|
|
|
|
def _norm_name(value) -> str:
|
|
"""Lowercase, strip bracketed qualifiers (Deluxe/Remaster/feat.) and
|
|
punctuation so names can be compared on their significant words."""
|
|
s = (value or '').lower()
|
|
s = re.sub(r'[\(\[\{].*?[\)\]\}]', ' ', s) # drop (...) [...] qualifiers
|
|
s = re.sub(r'\b(?:feat|ft|featuring)\b.*', ' ', s) # drop trailing "feat. X"
|
|
s = re.sub(r'[^a-z0-9]+', ' ', s)
|
|
return ' '.join(s.split())
|
|
|
|
|
|
def _name_tokens(value) -> set:
|
|
return set(_norm_name(value).split()) - _NAME_STOPWORDS
|
|
|
|
|
|
def _names_match(a, b) -> bool:
|
|
"""True when two names share all the significant words of the shorter one
|
|
(so "Album" matches "Album (Deluxe)", but unrelated titles don't)."""
|
|
ta, tb = _name_tokens(a), _name_tokens(b)
|
|
if not ta or not tb:
|
|
return False
|
|
return ta <= tb or tb <= ta
|
|
|
|
|
|
@register_job
|
|
class MissingCoverArtJob(RepairJob):
|
|
job_id = 'missing_cover_art'
|
|
display_name = 'Cover Art Filler'
|
|
description = 'Finds albums missing artwork and locates art from metadata sources'
|
|
help_text = (
|
|
'Scans your library for albums that have no cover art stored in the database. '
|
|
'For each missing cover, it searches for matching artwork using the album name '
|
|
'and artist. If you have configured cover-art sources (Settings > metadata '
|
|
'enhancement art order), those are used first; otherwise it falls back to '
|
|
'Prefer Source (if set) or the primary metadata source.\n\n'
|
|
'When artwork is found, a finding is created with the image URL so you can review '
|
|
'and apply it. The job does not download or embed artwork automatically.\n\n'
|
|
'Settings:\n'
|
|
'- Prefer Source: Optional source to try first; otherwise the primary metadata source is used'
|
|
)
|
|
icon = 'repair-icon-coverart'
|
|
default_enabled = True
|
|
default_interval_hours = 48
|
|
default_settings = {}
|
|
auto_fix = False
|
|
|
|
def scan(self, context: JobContext) -> JobResult:
|
|
result = JobResult()
|
|
|
|
settings = self._get_settings(context)
|
|
primary_source = get_primary_source()
|
|
source_priority = get_source_priority(primary_source)
|
|
# User's configured cover-art source order (caa/deezer/itunes/spotify/
|
|
# audiodb). Empty by default → falls back to the source-priority loop.
|
|
art_order = (context.config_manager.get('metadata_enhancement.album_art_order')
|
|
if context.config_manager else None)
|
|
prefer_source = settings.get('prefer_source')
|
|
if prefer_source and prefer_source != primary_source and prefer_source in source_priority:
|
|
source_priority.remove(prefer_source)
|
|
source_priority.insert(0, prefer_source)
|
|
if primary_source in source_priority:
|
|
source_priority.remove(primary_source)
|
|
source_priority.insert(1, primary_source)
|
|
|
|
# Fetch albums with missing artwork
|
|
albums = []
|
|
conn = None
|
|
try:
|
|
conn = context.db._get_connection()
|
|
cursor = conn.cursor()
|
|
cursor.execute("PRAGMA table_info(albums)")
|
|
album_columns = {column[1] for column in cursor.fetchall()}
|
|
|
|
select_cols = [
|
|
"al.id",
|
|
"al.title",
|
|
"ar.name",
|
|
"al.spotify_album_id",
|
|
"al.thumb_url",
|
|
"ar.thumb_url",
|
|
# A representative local track path, so we can check whether the
|
|
# album actually has art ON DISK (embedded / cover.jpg) — not just
|
|
# whether the DB row has a thumb_url.
|
|
("(SELECT t.file_path FROM tracks t WHERE t.album_id = al.id "
|
|
"AND t.file_path IS NOT NULL AND t.file_path != '' "
|
|
"ORDER BY t.disc_number, t.track_number LIMIT 1) AS rep_path"),
|
|
]
|
|
column_map = [
|
|
("itunes_album_id", "al.itunes_album_id"),
|
|
("deezer_album_id", "al.deezer_id"),
|
|
("discogs_album_id", "al.discogs_id"),
|
|
("hydrabase_album_id", "al.soul_id"),
|
|
]
|
|
column_index = {}
|
|
for alias, column in column_map:
|
|
if column.split('.', 1)[1] in album_columns:
|
|
column_index[alias] = len(select_cols)
|
|
select_cols.append(f"{column} AS {alias}")
|
|
|
|
# Scan every titled album — we decide per-album whether art is
|
|
# missing in the DB OR on disk (the file/cover.jpg). The on-disk
|
|
# check is cheap-first (a sidecar stat before opening any audio).
|
|
cursor.execute(f"""
|
|
SELECT {', '.join(select_cols)}
|
|
FROM albums al
|
|
LEFT JOIN artists ar ON ar.id = al.artist_id
|
|
WHERE al.title IS NOT NULL AND al.title != ''
|
|
""")
|
|
albums = cursor.fetchall()
|
|
except Exception as e:
|
|
logger.error("Error fetching albums without artwork: %s", e, exc_info=True)
|
|
result.errors += 1
|
|
return result
|
|
finally:
|
|
if conn:
|
|
conn.close()
|
|
|
|
total = len(albums)
|
|
if context.update_progress:
|
|
context.update_progress(0, total)
|
|
|
|
logger.info("Found %d albums missing cover art", total)
|
|
download_folder = (context.config_manager.get('soulseek.download_path', '')
|
|
if context.config_manager else None)
|
|
|
|
if context.report_progress:
|
|
context.report_progress(phase=f'Searching artwork for {total} albums...', total=total)
|
|
|
|
for i, row in enumerate(albums):
|
|
if context.check_stop():
|
|
return result
|
|
if i % 10 == 0 and context.wait_if_paused():
|
|
return result
|
|
|
|
album_id, title, artist_name, spotify_album_id, album_thumb, artist_thumb, rep_path = row[:7]
|
|
source_album_ids = {
|
|
'spotify': spotify_album_id,
|
|
'itunes': row[column_index['itunes_album_id']] if 'itunes_album_id' in column_index else None,
|
|
'deezer': row[column_index['deezer_album_id']] if 'deezer_album_id' in column_index else None,
|
|
'discogs': row[column_index['discogs_album_id']] if 'discogs_album_id' in column_index else None,
|
|
'hydrabase': row[column_index['hydrabase_album_id']] if 'hydrabase_album_id' in column_index else None,
|
|
}
|
|
result.scanned += 1
|
|
|
|
# Art can be missing in the DB (no thumb_url) and/or on disk (no
|
|
# embedded art and no cover.jpg). Skip albums that already have both.
|
|
db_missing = not (str(album_thumb).strip() if album_thumb else '')
|
|
# Resolve the representative path the SAME way the apply does
|
|
# (_fix_missing_cover_art) before checking disk art. Checking the raw
|
|
# DB path would fail on any path-mapped setup (docker mounts, a
|
|
# Plex/SoulSync path mismatch) — the file isn't found, album art
|
|
# reads as "missing", and EVERY album gets flagged while the apply
|
|
# (which resolves) then finds the art already present. Unresolvable →
|
|
# treat as no-local-file (don't claim disk-missing).
|
|
resolved_rep = resolve_library_file_path(
|
|
rep_path,
|
|
transfer_folder=getattr(context, 'transfer_folder', None),
|
|
download_folder=download_folder,
|
|
config_manager=context.config_manager,
|
|
) if rep_path else None
|
|
has_local = bool(resolved_rep)
|
|
# Check embedded art and the cover.jpg sidecar SEPARATELY (not the
|
|
# combined album_has_art_on_disk, which returns True if EITHER is
|
|
# present). An album can have embedded art but no cover.jpg — and if
|
|
# the user wants cover.jpg files, that's still a fixable "missing"
|
|
# (Sokhi: scans returned 0 because embedded-art albums were treated
|
|
# as fully arted and skipped, so their cover.jpg never got written).
|
|
has_embedded = file_has_embedded_art(resolved_rep) if has_local else False
|
|
has_sidecar = folder_has_cover_sidecar(os.path.dirname(resolved_rep)) if has_local else False
|
|
# cover.jpg sidecars are only a "missing" thing when the user has
|
|
# cover.jpg writing enabled (Boulder: "only scan for cover.jpgs when
|
|
# they're enabled"). Default on.
|
|
cover_sidecar_enabled = bool(
|
|
context.config_manager.get('metadata_enhancement.cover_art_download', True)
|
|
if context.config_manager else True)
|
|
|
|
if has_local:
|
|
embed_missing = not has_embedded
|
|
sidecar_missing = cover_sidecar_enabled and not has_sidecar
|
|
# has_embedded + no sidecar → the apply writes cover.jpg from the
|
|
# existing embedded art, so it's fixable even if the API finds no
|
|
# art. embed_missing still requires API art (nothing to embed).
|
|
sidecar_from_embedded = sidecar_missing and has_embedded
|
|
needs_fix = embed_missing or sidecar_missing
|
|
else:
|
|
# Media-server-only album: the DB thumb is the only art.
|
|
embed_missing = db_missing
|
|
sidecar_from_embedded = False
|
|
needs_fix = db_missing
|
|
if not needs_fix:
|
|
result.skipped += 1
|
|
continue
|
|
|
|
if context.report_progress:
|
|
context.report_progress(
|
|
scanned=i + 1, total=total,
|
|
phase=f'Searching {i + 1} / {total}',
|
|
log_line=f'Searching: {title or "Unknown"} — {artist_name or "Unknown"}',
|
|
log_type='info'
|
|
)
|
|
|
|
artwork_url = None
|
|
|
|
# Honor the user's configured cover-art sources first (the same
|
|
# metadata_enhancement.album_art_order the post-process embed and the
|
|
# Library Re-tag job use) so "cover art sources" means one thing
|
|
# app-wide. Non-breaking: returns None when no order is configured
|
|
# (the default), so we fall back to the prefer_source / metadata
|
|
# source-priority loop below — unchanged behavior for existing users.
|
|
try:
|
|
from core.metadata.art_lookup import select_preferred_art_url
|
|
artwork_url = select_preferred_art_url(
|
|
artist_name, title,
|
|
{'musicbrainz_release_id': None}, art_order,
|
|
)
|
|
except Exception as e:
|
|
logger.debug("preferred cover-art lookup failed for album %s: %s", album_id, e)
|
|
|
|
# Try source-specific IDs first, then title/artist search, in priority order.
|
|
if not artwork_url:
|
|
for source in source_priority:
|
|
artwork_url = self._try_source(source, source_album_ids.get(source), title, artist_name)
|
|
if artwork_url:
|
|
break
|
|
|
|
# Fixable if we found API art (to embed/write), OR it's just a
|
|
# missing cover.jpg on an album that already has embedded art — the
|
|
# apply writes the sidecar from that embedded art, no API art needed.
|
|
if artwork_url or sidecar_from_embedded:
|
|
if context.report_progress:
|
|
context.report_progress(
|
|
log_line=(f'Found art: {title or "Unknown"}' if artwork_url
|
|
else f'Will write cover.jpg from embedded art: {title or "Unknown"}'),
|
|
log_type='success'
|
|
)
|
|
# Also search for an artist image so the finding can offer it as
|
|
# an independently-applyable target (Pache711). Searched even
|
|
# when the artist already has art, so a wrong existing image can
|
|
# be swapped; the UI only surfaces it when it differs from the
|
|
# current one.
|
|
found_artist_url = self._find_artist_art(artist_name, source_priority)
|
|
# Create finding for user to approve
|
|
if context.create_finding:
|
|
try:
|
|
_desc = (f'Album "{title}" by {artist_name or "Unknown"} has no cover art. '
|
|
+ ('Found artwork from API.' if artwork_url
|
|
else 'Will write cover.jpg from the existing embedded art.'))
|
|
inserted = context.create_finding(
|
|
job_id=self.job_id,
|
|
finding_type='missing_cover_art',
|
|
severity='info',
|
|
entity_type='album',
|
|
entity_id=str(album_id),
|
|
file_path=None,
|
|
title=f'Missing artwork: {title or "Unknown"}',
|
|
description=_desc,
|
|
details={
|
|
'album_id': album_id,
|
|
'album_title': title,
|
|
'artist': artist_name,
|
|
'found_artwork_url': artwork_url,
|
|
'spotify_album_id': spotify_album_id,
|
|
'artist_thumb_url': artist_thumb or None,
|
|
# Found artist image (None if none matched, or it
|
|
# equals the current one — nothing to offer then).
|
|
'found_artist_url': (
|
|
found_artist_url
|
|
if found_artist_url and found_artist_url != artist_thumb
|
|
else None
|
|
),
|
|
# Where the files live + what was missing, so the
|
|
# apply can embed into the audio + write cover.jpg.
|
|
'album_folder': os.path.dirname(rep_path) if rep_path else None,
|
|
'db_missing': db_missing,
|
|
'embed_missing': embed_missing,
|
|
'sidecar_from_embedded': sidecar_from_embedded,
|
|
'musicbrainz_release_id': None,
|
|
}
|
|
)
|
|
if inserted:
|
|
result.findings_created += 1
|
|
else:
|
|
result.findings_skipped_dedup += 1
|
|
except Exception as e:
|
|
logger.debug("Error creating cover art finding for album %s: %s", album_id, e)
|
|
result.errors += 1
|
|
else:
|
|
result.skipped += 1
|
|
|
|
if context.update_progress and (i + 1) % 5 == 0:
|
|
context.update_progress(i + 1, total)
|
|
|
|
if context.update_progress:
|
|
context.update_progress(total, total)
|
|
|
|
logger.info("Cover art scan: %d albums checked, %d found art, %d skipped",
|
|
result.scanned, result.findings_created, result.skipped)
|
|
return result
|
|
|
|
def _try_source(self, source, source_album_id, title, artist_name):
|
|
"""Try to get album art from a specific metadata source."""
|
|
client = get_client_for_source(source)
|
|
if not client:
|
|
return None
|
|
|
|
query = f"{artist_name} {title}" if artist_name else title
|
|
|
|
try:
|
|
if source_album_id:
|
|
album_data = self._get_album_for_source(source, client, source_album_id)
|
|
artwork_url = self._extract_artwork_url(album_data)
|
|
if artwork_url:
|
|
return artwork_url
|
|
|
|
if query and hasattr(client, 'search_albums'):
|
|
# Pull a few results and only accept one whose title AND artist
|
|
# actually match this album. The old code grabbed results[0]'s
|
|
# artwork unconditionally, so a loose full-text search returning
|
|
# the wrong album gave the wrong cover.
|
|
results = client.search_albums(query, limit=5) or []
|
|
for res in results:
|
|
if not self._result_matches(res, title, artist_name):
|
|
continue
|
|
artwork_url = self._extract_artwork_url(res)
|
|
if artwork_url:
|
|
return artwork_url
|
|
candidate_id = self._extract_album_id(res)
|
|
if candidate_id:
|
|
album_data = self._get_album_for_source(source, client, candidate_id)
|
|
artwork_url = self._extract_artwork_url(album_data)
|
|
if artwork_url:
|
|
return artwork_url
|
|
except Exception as e:
|
|
logger.debug("%s art lookup failed for '%s': %s", source.capitalize(), title, e)
|
|
return None
|
|
|
|
def _find_artist_art(self, artist_name, source_priority):
|
|
"""Search the configured sources for an artist image, in priority
|
|
order. Returns the first confidently name-matched artist image URL,
|
|
or None. Mirrors _try_source but for artists (Pache711: let the
|
|
Cover Art Filler offer artist art as its own fixable target)."""
|
|
if not artist_name:
|
|
return None
|
|
for source in source_priority:
|
|
client = get_client_for_source(source)
|
|
if not client or not hasattr(client, 'search_artists'):
|
|
continue
|
|
try:
|
|
for res in (client.search_artists(artist_name, limit=5) or []):
|
|
r_name = getattr(res, 'name', None)
|
|
if isinstance(res, dict):
|
|
r_name = res.get('name')
|
|
# Exact significant-word match — never hang a wrong artist
|
|
# photo on someone just because the search was fuzzy.
|
|
if not r_name or _name_tokens(r_name) != _name_tokens(artist_name):
|
|
continue
|
|
url = self._extract_artwork_url(res)
|
|
if url:
|
|
return url
|
|
except Exception as e:
|
|
logger.debug("%s artist-art lookup failed for '%s': %s",
|
|
source.capitalize(), artist_name, e)
|
|
return None
|
|
|
|
@staticmethod
|
|
def _result_title_artist(item):
|
|
"""Pull (title, artist) from a search result that may be a dict or an
|
|
Album-like object, across the various source clients."""
|
|
if item is None:
|
|
return '', ''
|
|
if isinstance(item, dict):
|
|
title = item.get('title') or item.get('name') or item.get('album') or ''
|
|
artist = item.get('artist') or item.get('artist_name') or ''
|
|
if not artist:
|
|
artists = item.get('artists') or []
|
|
if isinstance(artists, list) and artists:
|
|
a0 = artists[0]
|
|
artist = a0.get('name', '') if isinstance(a0, dict) else str(a0)
|
|
else:
|
|
title = getattr(item, 'title', None) or getattr(item, 'name', None) or getattr(item, 'album', None) or ''
|
|
artist = getattr(item, 'artist', None) or getattr(item, 'artist_name', None) or ''
|
|
if not artist:
|
|
arts = getattr(item, 'artists', None) or []
|
|
if isinstance(arts, list) and arts:
|
|
a0 = arts[0]
|
|
artist = a0.get('name', '') if isinstance(a0, dict) else str(a0)
|
|
return str(title or ''), str(artist or '')
|
|
|
|
@classmethod
|
|
def _result_matches(cls, result, album_title, album_artist) -> bool:
|
|
"""Reject a search result unless it confidently matches the album.
|
|
|
|
Title must match; if both the result and the album carry an artist, the
|
|
artist must match too (the strongest guard against wrong covers). When
|
|
the result has no artist to compare, require an exact title match.
|
|
"""
|
|
r_title, r_artist = cls._result_title_artist(result)
|
|
# Title may carry extra qualifiers (Deluxe/Remaster) → allow subset.
|
|
if not _names_match(r_title, album_title):
|
|
return False
|
|
# Artist is the strong guard, so require its significant words to match
|
|
# EXACTLY (not subset) — "Different Artist" must NOT match "Artist".
|
|
if r_artist and album_artist:
|
|
return _name_tokens(r_artist) == _name_tokens(album_artist)
|
|
# No artist on the result → require an exact title match instead.
|
|
return _norm_name(r_title) == _norm_name(album_title)
|
|
|
|
@staticmethod
|
|
def _get_album_for_source(source, client, album_id):
|
|
if source == 'spotify':
|
|
return client.get_album(album_id)
|
|
return client.get_album(album_id, include_tracks=False)
|
|
|
|
@staticmethod
|
|
def _extract_album_id(item):
|
|
if hasattr(item, 'id'):
|
|
return getattr(item, 'id', None)
|
|
if isinstance(item, dict):
|
|
return item.get('id')
|
|
return None
|
|
|
|
@staticmethod
|
|
def _extract_artwork_url(item):
|
|
if not item:
|
|
return None
|
|
if hasattr(item, 'image_url') and getattr(item, 'image_url', None):
|
|
return item.image_url
|
|
if isinstance(item, dict):
|
|
if item.get('image_url'):
|
|
return item['image_url']
|
|
images = item.get('images') or []
|
|
if images and isinstance(images, list):
|
|
first = images[0]
|
|
if isinstance(first, dict):
|
|
return first.get('url')
|
|
return None
|
|
|
|
def _get_settings(self, context: JobContext) -> dict:
|
|
if not context.config_manager:
|
|
return self.default_settings.copy()
|
|
cfg = context.config_manager.get(f'repair.jobs.{self.job_id}.settings', {})
|
|
merged = self.default_settings.copy()
|
|
merged.update(cfg)
|
|
return merged
|
|
|
|
def estimate_scope(self, context: JobContext) -> int:
|
|
conn = None
|
|
try:
|
|
conn = context.db._get_connection()
|
|
cursor = conn.cursor()
|
|
# Upper bound: every titled album is examined (the per-album DB/disk
|
|
# art check decides which actually need filling).
|
|
cursor.execute("""
|
|
SELECT COUNT(*) FROM albums
|
|
WHERE title IS NOT NULL AND title != ''
|
|
""")
|
|
row = cursor.fetchone()
|
|
return row[0] if row else 0
|
|
except Exception:
|
|
return 0
|
|
finally:
|
|
if conn:
|
|
conn.close()
|