"""AcoustID Scanner Job — fingerprints library tracks to detect wrong downloads. Scans the entire library (not just Transfer) by resolving DB file paths to actual files on disk. Creates actionable findings that can be fixed: - 'retag': Update DB metadata to match what the file actually is - 'redownload': Add the expected track to wishlist and delete the wrong file - 'delete': Remove the wrong file and its DB record """ import os import re from difflib import SequenceMatcher from typing import Optional 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.acoustid") AUDIO_EXTENSIONS = {'.mp3', '.flac', '.ogg', '.opus', '.m4a', '.aac', '.wav', '.wma', '.aiff', '.aif'} @register_job class AcoustIDScannerJob(RepairJob): job_id = 'acoustid_scanner' display_name = 'AcoustID Scanner' description = 'Fingerprints library tracks to detect wrong downloads' help_text = ( 'Scans your music library by fingerprinting audio files and comparing ' 'them against the AcoustID database. Detects cases where the wrong song ' 'was downloaded — even if the filename and tags look correct.\n\n' 'When a mismatch is found, you can:\n' '• Retag — update the DB record to match the actual audio content\n' '• Redownload — add the correct track to your wishlist and remove the wrong file\n' '• Delete — remove the wrong file entirely\n\n' 'The job processes tracks in batches with checkpointing so it resumes ' 'where it left off across runs. Requires an AcoustID API key (Settings).\n\n' 'Settings:\n' '- Fingerprint Threshold: Minimum AcoustID match confidence (0.0–1.0)\n' '- Title Similarity: How closely the identified title must match\n' '- Artist Similarity: How closely the identified artist must match\n' '- Batch Size: Tracks per scan run (checkpoint saved between batches)' ) icon = 'repair-icon-acoustid' default_enabled = True default_interval_hours = 24 default_settings = { 'fingerprint_threshold': 0.80, 'title_similarity': 0.70, 'artist_similarity': 0.60, 'batch_size': 200, } auto_fix = False # User chooses fix action per finding def scan(self, context: JobContext) -> JobResult: result = JobResult() settings = self._get_settings(context) fp_threshold = settings.get('fingerprint_threshold', 0.80) title_threshold = settings.get('title_similarity', 0.70) artist_threshold = settings.get('artist_similarity', 0.60) batch_size = settings.get('batch_size', 200) # Get AcoustID client acoustid_client = context.acoustid_client if not acoustid_client: try: from core.acoustid_client import AcoustIDClient acoustid_client = AcoustIDClient() except Exception as e: logger.warning("AcoustID client not available: %s", e) return result # Load all library tracks from DB with their file paths db_tracks = self._load_db_tracks(context) if not db_tracks: logger.info("No library tracks with file paths found") return result # Read checkpoint (last processed track ID) to resume from checkpoint_id = None if context.config_manager: checkpoint_id = context.config_manager.get( f'repair.jobs.{self.job_id}.checkpoint_id', None ) if checkpoint_id is not None: checkpoint_id = str(checkpoint_id) # Build ordered list of (track_id, info) sorted by ID for deterministic order track_list = sorted(db_tracks.items(), key=lambda x: str(x[0])) # Skip past checkpoint if resuming if checkpoint_id is not None: original_len = len(track_list) track_list = [(tid, info) for tid, info in track_list if str(tid) > checkpoint_id] if len(track_list) < original_len: logger.info("Resuming AcoustID scan from checkpoint ID %s (%d tracks remaining)", checkpoint_id, len(track_list)) total = len(track_list) if context.report_progress: context.report_progress(phase=f'Scanning {total} library tracks...', total=total) if context.update_progress: context.update_progress(0, total) batch_count = 0 for i, (track_id, track_info) in enumerate(track_list): if context.check_stop(): self._save_checkpoint_id(context, track_id) return result if i % 10 == 0 and context.wait_if_paused(): self._save_checkpoint_id(context, track_id) return result # Resolve the DB path to an actual file on disk file_path = track_info.get('file_path', '') resolved = self._resolve_path(file_path, context) if not resolved: result.skipped += 1 continue result.scanned += 1 batch_count += 1 fname = os.path.basename(resolved) if context.report_progress: context.report_progress( scanned=i + 1, total=total, phase=f'Fingerprinting {i + 1} / {total}', log_line=f'Scanning: {fname}', log_type='info' ) try: self._scan_file( resolved, track_id, track_info, acoustid_client, context, result, fp_threshold, title_threshold, artist_threshold ) except Exception as e: logger.debug("Error scanning %s: %s", fname, e) result.errors += 1 # Rate limit: pause between batches to avoid hammering AcoustID API if batch_count >= batch_size: batch_count = 0 self._save_checkpoint_id(context, track_id) if context.sleep_or_stop(2): return result if context.update_progress and (i + 1) % 10 == 0: context.update_progress(i + 1, total) # Clear checkpoint on full completion self._save_checkpoint_id(context, None) if context.update_progress: context.update_progress(total, total) logger.info("AcoustID scan: %d scanned, %d skipped, %d mismatches, %d errors", result.scanned, result.skipped, result.findings_created, result.errors) return result def _scan_file(self, fpath, track_id, expected, acoustid_client, context, result, fp_threshold, title_threshold, artist_threshold): """Fingerprint a single file and check for mismatches.""" fname = os.path.basename(fpath) # Fingerprint the file try: fp_result = acoustid_client.fingerprint_and_lookup(fpath) except Exception as e: logger.debug("Fingerprint failed for %s: %s", fname, e) result.errors += 1 if context.report_progress: context.report_progress(log_line=f'Error: {fname} — {e}', log_type='error') return if not fp_result or not fp_result.get('recordings'): if context.report_progress: context.report_progress(log_line=f'No match: {fname}', log_type='skip') return best_score = fp_result.get('best_score', 0) if best_score < fp_threshold: return best_recording = fp_result['recordings'][0] aid_title = best_recording.get('title', '') aid_artist = best_recording.get('artist', '') if not aid_title: return # Resolve which artist value to compare against, in priority order: # 1. DB `track_artist` (per-track, manually curated or scanner- # populated) — trust it when populated. Respects user edits # from the enhanced library view. # 2. File's ARTIST tag — ground truth for what's on disk. # Catches legacy compilation tracks where `track_artist` # column is NULL because they were downloaded before that # column existed; the file itself has the correct per- # track artist (Tidal/Spotify/Deezer all write it). # 3. Album artist — final fallback for files without proper # ARTIST tags AND no DB track_artist. track_artist = (expected.get('track_artist') or '').strip() if track_artist: expected_artist = track_artist else: file_artist = None try: from core.tag_writer import read_file_tags file_tags = read_file_tags(fpath) file_artist = (file_tags.get('artist') or '').strip() or None except Exception as e: logger.debug("file-tag artist read failed for %s: %s", fname, e) expected_artist = ( file_artist or (expected.get('album_artist') or '').strip() or expected['artist'] ) # Normalize and compare norm_expected_title = _normalize(expected['title']) norm_aid_title = _normalize(aid_title) norm_expected_artist = _normalize(expected_artist) norm_aid_artist = _normalize(aid_artist) title_sim = SequenceMatcher(None, norm_expected_title, norm_aid_title).ratio() # Issue (Foxxify Discord report): AcoustID returns the FULL artist # credit (e.g. `Okayracer, aldrch & poptropicaslutz!`) while the # library DB carries only the primary artist (`Okayracer`). Raw # similarity scores ~43% — well below threshold — so multi-artist # tracks get flagged as Wrong Song even though the primary IS in # the credit. Route through the shared `artist_names_match` helper # which splits the credit on common separators (comma, ampersand, # feat./ft./with/vs., etc.) and checks each token. Primary-in- # credit cases now resolve at 100% match instead of 43%. # # Pass RAW artist strings (not pre-normalised) so the splitter # can recognise the separators. The helper applies its own # case + whitespace normalisation internally per token. if norm_expected_artist: from core.matching.artist_aliases import artist_names_match _, artist_sim = artist_names_match( expected_artist, aid_artist, threshold=artist_threshold, ) else: artist_sim = 1.0 if title_sim >= title_threshold and artist_sim >= artist_threshold: return # Issue #587 (Foxxify) — top recording's metadata mismatched, but # AcoustID often returns multiple recordings per fingerprint # (sample collisions, multi-MB-record cases). Check ALL of them # before flagging — if any candidate's metadata matches expected # title + artist, the file IS the right song and AcoustID's top # match was just a wrong-credited recording. from core.matching.acoustid_candidates import ( duration_mismatches_strongly, find_matching_recording, ) from core.matching.artist_aliases import artist_names_match def _scanner_title_sim(a, b): return SequenceMatcher(None, _normalize(a), _normalize(b)).ratio() def _scanner_artist_sim(expected_a, actual_a): _, score = artist_names_match(expected_a, actual_a, threshold=artist_threshold) return score candidate_match, _, _ = find_matching_recording( fp_result.get('recordings') or [], expected['title'], expected_artist, title_threshold=title_threshold, artist_threshold=artist_threshold, similarity=_scanner_title_sim, artist_similarity=_scanner_artist_sim, ) if candidate_match is not None: # A lower-ranked candidate matched — file IS the right song. # No finding. if context.report_progress: context.report_progress( log_line=( f'Resolved (lower-ranked candidate match): {fname} — ' f'expected "{expected["title"]}" matched candidate ' f'"{candidate_match.get("title")}" by ' f'"{candidate_match.get("artist")}"' ), log_type='ok', ) return # Issue #587 (Foxxify "17min mashup → 5min track") — duration # guard against fingerprint hash collisions. When the file's # actual duration differs from AcoustID's matched recording by # more than max(60s, 35%), the fingerprint is almost certainly # a sample/intro collision, not a real recording match. Don't # produce a confident "Wrong Song" finding. try: file_duration_s = (expected.get('duration_ms') or 0) / 1000.0 except Exception: file_duration_s = 0 candidate_duration_s = best_recording.get('duration') if candidate_duration_s is None and best_recording.get('length'): candidate_duration_s = best_recording.get('length') if duration_mismatches_strongly(file_duration_s, candidate_duration_s): if context.report_progress: context.report_progress( log_line=( f'Skipped (duration mismatch suggests fingerprint collision): ' f'{fname} — expected {file_duration_s:.0f}s, AcoustID ' f'candidate {candidate_duration_s:.0f}s' ), log_type='skip', ) return # Mismatch detected if context.report_progress: context.report_progress( log_line=f'Mismatch: {fname} — expected "{expected["title"]}", got "{aid_title}"', log_type='error' ) if context.create_finding: severity = 'warning' if best_score >= 0.90 else 'info' inserted = context.create_finding( job_id=self.job_id, finding_type='acoustid_mismatch', severity=severity, entity_type='track', entity_id=str(track_id), file_path=fpath, title=f'Wrong download: "{expected["title"]}" is actually "{aid_title}"', description=( f'Expected "{expected["title"]}" by {expected_artist}, ' f'but audio fingerprint matches "{aid_title}" by {aid_artist} ' f'(fingerprint: {best_score:.0%}, title match: {title_sim:.0%}, ' f'artist match: {artist_sim:.0%})' ), details={ 'expected_title': expected['title'], 'expected_artist': expected_artist, 'acoustid_title': aid_title, 'acoustid_artist': aid_artist, 'fingerprint_score': round(best_score, 3), 'title_similarity': round(title_sim, 3), 'artist_similarity': round(artist_sim, 3), 'album_thumb_url': expected.get('album_thumb_url'), 'artist_thumb_url': expected.get('artist_thumb_url'), 'album_title': expected.get('album_title', ''), 'track_number': expected.get('track_number'), } ) if inserted: result.findings_created += 1 else: result.findings_skipped_dedup += 1 def _load_db_tracks(self, context: JobContext) -> dict: """Load all tracks from DB keyed by track ID.""" tracks = {} conn = None try: conn = context.db._get_connection() cursor = conn.cursor() # Discord report (Skowl): compilation albums like "High Tea # Music: Vol 1" have a different artist per track but the # `tracks.artist_id` foreign key points at the ALBUM artist # (curator / label-name applied to every track). AcoustID # returns the actual per-track artist → 12% similarity → # Wrong Song flag. Fix: prefer `tracks.track_artist` (the # per-track artist, populated by every server-scan + auto- # import path when different from album artist) and fall # back to the album artist only when the per-track column # is NULL or empty (legacy rows / single-artist albums). # Load `track_artist` (raw, may be empty) AND `album_artist` # separately so `_scan_file` can tell the difference between # 'DB has a curated per-track value' and 'DB fell back to # album artist'. The COALESCE'd `artist` field is kept as a # convenience for the existing `expected['artist']` consumers # that want a single resolved value, but the resolution # priority that actually drives the comparison is reproduced # in `_scan_file`: track_artist → file tag → album_artist. cursor.execute(""" SELECT t.id, t.title, COALESCE(NULLIF(t.track_artist, ''), ar.name) AS artist, t.file_path, t.track_number, al.title AS album_title, al.thumb_url, ar.thumb_url, NULLIF(t.track_artist, '') AS track_artist, ar.name AS album_artist, t.duration FROM tracks t LEFT JOIN artists ar ON ar.id = t.artist_id LEFT JOIN albums al ON al.id = t.album_id WHERE t.file_path IS NOT NULL AND t.file_path != '' AND t.title IS NOT NULL AND t.title != '' """) for row in cursor.fetchall(): track_id = row[0] if track_id is None: logger.warning( "Skipping track row with null ID while loading AcoustID scan candidates: %s", row[3] or "", ) continue track_id = str(track_id) tracks[track_id] = { 'title': row[1] or '', 'artist': row[2] or '', 'file_path': row[3] or '', 'track_number': row[4], 'album_title': row[5] or '', 'album_thumb_url': row[6] or None, 'artist_thumb_url': row[7] or None, 'track_artist': row[8] or '', # raw (may be empty) 'album_artist': row[9] or '', # Duration in MS (DB stores ms). Used by the # duration-mismatch guard to spot fingerprint # collisions where the matched recording is a # totally different length. 'duration_ms': row[10] or 0, } except Exception as e: logger.error("Error loading tracks from DB: %s", e) finally: if conn: conn.close() return tracks def _resolve_path(self, file_path, context): """Resolve a DB file path to an actual file on disk.""" if not file_path: return None if os.path.exists(file_path): return file_path # Use the shared library-path resolver — picks up # library.music_paths and Plex library locations too. from core.library.path_resolver import resolve_library_file_path return resolve_library_file_path( file_path, transfer_folder=context.transfer_folder, config_manager=context.config_manager, ) def _save_checkpoint_id(self, context: JobContext, track_id): """Save or clear the scan checkpoint by track ID.""" if context.config_manager: context.config_manager.set( f'repair.jobs.{self.job_id}.checkpoint_id', track_id ) 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() cursor.execute(""" SELECT COUNT(*) FROM tracks WHERE file_path IS NOT NULL AND file_path != '' AND title IS NOT NULL AND title != '' """) return cursor.fetchone()[0] except Exception: return 0 finally: if conn: conn.close() def _normalize(text: str) -> str: t = text.lower() t = re.sub(r'\(.*?\)', '', t) t = re.sub(r'\[.*?\]', '', t) t = re.sub(r'[^a-z0-9 ]', '', t) return t.strip()