From 2d511d0a1685f7e85abc244da2267d6c8acde706 Mon Sep 17 00:00:00 2001
From: Broque Thomas <26755000+Nezreka@users.noreply.github.com>
Date: Sat, 21 Mar 2026 10:21:06 -0700
Subject: [PATCH] Add SoulID worker with API-based debut year disambiguation
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit
SoulID worker generates deterministic soul IDs for all library entities:
- Artists: hash(name + debut_year) — searches iTunes + Deezer APIs,
verifies correct artist by matching discography against local DB
albums via MusicMatchingEngine, pools years from both sources and
picks the earliest. Falls back to hash(name) if no match found.
- Albums: hash(artist + album)
- Tracks: song ID hash(artist + track) + album ID hash(artist + album + track)
Dashboard button with trans2.png logo, rainbow spinner, hover tooltip.
Worker orb with rainbow effect. SoulSync badge on library artist cards.
DB migration adds soul_id columns with indexes to artists/albums/tracks.
Migration version flag auto-resets artist soul IDs when algorithm changes.
---
core/soulid_worker.py | 579 ++++++++++++++++++++++++++++++++++++
database/music_database.py | 41 ++-
web_server.py | 32 ++
webui/index.html | 21 ++
webui/static/script.js | 49 +++
webui/static/style.css | 199 +++++++++++++
webui/static/trans.png | Bin 0 -> 193183 bytes
webui/static/worker-orbs.js | 1 +
8 files changed, 921 insertions(+), 1 deletion(-)
create mode 100644 core/soulid_worker.py
create mode 100644 webui/static/trans.png
diff --git a/core/soulid_worker.py b/core/soulid_worker.py
new file mode 100644
index 00000000..a2654b0d
--- /dev/null
+++ b/core/soulid_worker.py
@@ -0,0 +1,579 @@
+"""
+SoulID Worker — generates deterministic soul IDs for artists, albums, and tracks.
+
+Runs as a background worker that processes library entries without soul IDs,
+computes a deterministic hash from normalized metadata, and stores the result.
+
+Hash inputs (all lowercased, stripped of accents/punctuation, collapsed):
+ - Artist: normalize(artist_name) + normalize(debut_year) if known
+ Debut year is sourced from iTunes + Deezer APIs (not local DB)
+ to ensure deterministic results across all SoulSync nodes.
+ - Album: normalize(artist_name) + normalize(album_name)
+ - Track (song): normalize(artist_name) + normalize(track_name)
+ - Track (album): normalize(artist_name) + normalize(album_name) + normalize(track_name)
+
+The "song" soul ID links different versions of the same song (single vs album).
+The "album track" soul ID is specific to a track on a particular release.
+"""
+
+import hashlib
+import re
+import threading
+import time
+import unicodedata
+from typing import Dict, Any, List, Optional
+
+from utils.logging_config import get_logger
+
+logger = get_logger("soulid_worker")
+
+
+def normalize_for_soul_id(text: str) -> str:
+ """Aggressively normalize a string for deterministic hashing.
+
+ - Lowercase
+ - Strip accents/diacritics (Beyoncé → beyonce)
+ - Remove parentheticals: (feat. X), (Deluxe), (Remastered), [Live], etc.
+ - Remove all non-alphanumeric characters
+ - Collapse whitespace
+ """
+ if not text:
+ return ''
+ s = text.lower()
+ # Decompose unicode and strip combining marks (accents)
+ s = unicodedata.normalize('NFD', s)
+ s = ''.join(c for c in s if unicodedata.category(c) != 'Mn')
+ # Remove parenthetical/bracket suffixes
+ s = re.sub(r'\s*[\(\[][^)\]]*[\)\]]', '', s)
+ # Remove all non-alphanumeric
+ s = re.sub(r'[^a-z0-9]', '', s)
+ return s
+
+
+def generate_soul_id(*parts: str) -> str:
+ """Generate a soul ID from normalized parts.
+
+ Returns a 'soul_' prefixed hex string (first 16 chars of SHA-256).
+ """
+ combined = ''.join(normalize_for_soul_id(p) for p in parts if p)
+ if not combined:
+ return ''
+ digest = hashlib.sha256(combined.encode('utf-8')).hexdigest()[:16]
+ return f'soul_{digest}'
+
+
+class SoulIDWorker:
+ """Background worker that generates soul IDs for all library entities.
+
+ Artists are processed one at a time (API calls to iTunes/Deezer for
+ deterministic debut year). Albums and tracks are processed in batches
+ (local DB only, no API calls).
+ """
+
+ def __init__(self, database):
+ self.db = database
+
+ # Worker state
+ self.running = False
+ self.paused = False
+ self.should_stop = False
+ self.thread = None
+ self.current_item = None
+
+ # API clients (lazy-initialized)
+ self._itunes_client = None
+ self._deezer_client = None
+ self._matching_engine = None
+
+ # Statistics
+ self.stats = {
+ 'artists_processed': 0,
+ 'albums_processed': 0,
+ 'tracks_processed': 0,
+ 'errors': 0,
+ 'pending': 0,
+ }
+
+ # Processing config
+ self.batch_size = 100 # For albums/tracks (no API calls)
+ self.artist_sleep = 3.0 # Between artist API lookups (rate limit courtesy)
+ self.inter_batch_sleep = 0.5 # Between album/track batches
+ self.idle_sleep = 30
+ self.album_match_threshold = 0.80
+
+ logger.info("SoulID worker initialized")
+
+ def _get_itunes_client(self):
+ if self._itunes_client is None:
+ try:
+ from core.itunes_client import iTunesClient
+ self._itunes_client = iTunesClient()
+ except Exception as e:
+ logger.error(f"Failed to init iTunes client: {e}")
+ return self._itunes_client
+
+ def _get_deezer_client(self):
+ if self._deezer_client is None:
+ try:
+ from core.deezer_client import DeezerClient
+ self._deezer_client = DeezerClient()
+ except Exception as e:
+ logger.error(f"Failed to init Deezer client: {e}")
+ return self._deezer_client
+
+ def _get_matching_engine(self):
+ if self._matching_engine is None:
+ try:
+ from core.matching_engine import MusicMatchingEngine
+ self._matching_engine = MusicMatchingEngine()
+ except Exception as e:
+ logger.error(f"Failed to init matching engine: {e}")
+ return self._matching_engine
+
+ def start(self):
+ if self.running:
+ return
+ self.running = True
+ self.should_stop = False
+ self.thread = threading.Thread(target=self._run, daemon=True)
+ self.thread.start()
+ logger.info("SoulID worker started")
+
+ def stop(self):
+ if not self.running:
+ return
+ self.should_stop = True
+ self.running = False
+ if self.thread:
+ self.thread.join(timeout=5)
+ logger.info("SoulID worker stopped")
+
+ def pause(self):
+ self.paused = True
+
+ def resume(self):
+ self.paused = False
+
+ def get_stats(self) -> Dict[str, Any]:
+ self.stats['pending'] = self._count_pending()
+ is_running = self.running and self.thread is not None and self.thread.is_alive()
+ is_idle = is_running and not self.paused and self.stats['pending'] == 0
+ return {
+ 'enabled': True,
+ 'running': is_running and not self.paused,
+ 'paused': self.paused,
+ 'idle': is_idle,
+ 'current_item': self.current_item,
+ 'stats': self.stats.copy(),
+ }
+
+ # ── Main loop ──
+
+ def _run(self):
+ logger.info("SoulID worker thread started")
+
+ # One-time migration: reset artist soul IDs when algorithm changes
+ self._migrate_artist_soul_ids()
+
+ while not self.should_stop:
+ try:
+ if self.paused:
+ time.sleep(1)
+ continue
+
+ processed = 0
+ processed += self._process_next_artist()
+ processed += self._process_albums()
+ processed += self._process_tracks()
+
+ if processed == 0:
+ self.current_item = None
+ time.sleep(self.idle_sleep)
+ else:
+ # Albums/tracks get inter_batch_sleep, artists get their
+ # own sleep inside _process_next_artist
+ time.sleep(self.inter_batch_sleep)
+
+ except Exception as e:
+ logger.error(f"Error in SoulID worker loop: {e}", exc_info=True)
+ self.stats['errors'] += 1
+ time.sleep(5)
+
+ self.current_item = None
+ logger.info("SoulID worker thread finished")
+
+ # ── Artist processing (one at a time, API-based) ──
+
+ def _process_next_artist(self) -> int:
+ """Process a single artist — queries iTunes + Deezer for debut year."""
+ conn = None
+ try:
+ conn = self.db._get_connection()
+ cursor = conn.cursor()
+ cursor.execute("""
+ SELECT id, name FROM artists
+ WHERE (soul_id IS NULL OR soul_id = '')
+ AND name IS NOT NULL AND name != ''
+ AND id IS NOT NULL
+ LIMIT 1
+ """)
+ row = cursor.fetchone()
+ if not row:
+ return 0
+
+ artist_id, name = row
+ self.current_item = f"Artist: {name}"
+
+ # Get this artist's album names from our DB for cross-referencing
+ cursor.execute("""
+ SELECT title FROM albums
+ WHERE artist_id = ? AND title IS NOT NULL AND title != ''
+ """, (artist_id,))
+ db_album_names = [r[0] for r in cursor.fetchall()]
+
+ # Look up debut year from iTunes + Deezer APIs
+ debut_year = self._lookup_debut_year(name, db_album_names)
+
+ if debut_year:
+ soul_id = generate_soul_id(name, debut_year)
+ self.current_item = f"Artist: {name} ({debut_year})"
+ else:
+ soul_id = generate_soul_id(name)
+
+ if not soul_id:
+ soul_id = f'soul_unnamed_{artist_id}'
+
+ cursor.execute(
+ "UPDATE artists SET soul_id = ? WHERE id = ? AND (soul_id IS NULL OR soul_id = '')",
+ (soul_id, artist_id)
+ )
+ conn.commit()
+ self.stats['artists_processed'] += 1
+ logger.info(f"Generated soul ID for artist: {name}" + (f" (debut {debut_year})" if debut_year else ""))
+
+ # Rate limit courtesy for API calls
+ time.sleep(self.artist_sleep)
+ return 1
+
+ except Exception as e:
+ logger.error(f"Error processing artist: {e}")
+ self.stats['errors'] += 1
+ if conn:
+ try:
+ conn.rollback()
+ except Exception:
+ pass
+ return 0
+ finally:
+ if conn:
+ conn.close()
+
+ def _lookup_debut_year(self, artist_name: str, db_album_names: List[str]) -> Optional[str]:
+ """Look up an artist's debut year from iTunes and Deezer.
+
+ Searches both sources for the artist, verifies the match by comparing
+ their discography against our DB albums, then pools all album years
+ from both matched sources and returns the earliest.
+
+ Args:
+ artist_name: Artist name to search for
+ db_album_names: Album names from our DB for this artist
+
+ Returns:
+ Earliest release year as string (e.g. '2011'), or None
+ """
+ if not db_album_names:
+ # No albums to cross-reference — can't verify which artist is correct
+ return None
+
+ matching = self._get_matching_engine()
+ if not matching:
+ return None
+
+ # Search both sources
+ itunes = self._get_itunes_client()
+ deezer = self._get_deezer_client()
+
+ itunes_results = []
+ deezer_results = []
+
+ try:
+ if itunes:
+ itunes_results = itunes.search_artists(artist_name, limit=5) or []
+ except Exception as e:
+ logger.debug(f"iTunes artist search failed for '{artist_name}': {e}")
+
+ try:
+ if deezer:
+ deezer_results = deezer.search_artists(artist_name, limit=5) or []
+ except Exception as e:
+ logger.debug(f"Deezer artist search failed for '{artist_name}': {e}")
+
+ # Each source independently steps through its results to find a match
+ itunes_discog = self._find_matching_discography(itunes, itunes_results, db_album_names, matching, 'iTunes')
+ deezer_discog = self._find_matching_discography(deezer, deezer_results, db_album_names, matching, 'Deezer')
+
+ # Pool all albums from both matched sources
+ all_years = []
+ for discog in (itunes_discog, deezer_discog):
+ if discog:
+ for album in discog:
+ year = self._extract_year(album)
+ if year:
+ all_years.append(year)
+
+ if all_years:
+ return min(all_years)
+
+ return None
+
+ def _find_matching_discography(self, client, artist_results, db_album_names: List[str],
+ matching, source_name: str) -> Optional[list]:
+ """Step through artist search results, return the discography of the first
+ one whose albums overlap with our DB albums.
+
+ Args:
+ client: iTunes or Deezer client
+ artist_results: List of Artist dataclass objects from search
+ db_album_names: Our DB album names for comparison
+ matching: MatchingEngine instance
+ source_name: 'iTunes' or 'Deezer' for logging
+
+ Returns:
+ List of Album objects from the matched artist's discography, or None
+ """
+ if not client or not artist_results:
+ return None
+
+ for artist in artist_results:
+ try:
+ discog = client.get_artist_albums(artist.id, album_type='album,single', limit=50)
+ if not discog:
+ continue
+
+ # Check if any discography album matches any DB album
+ for api_album in discog:
+ api_name = api_album.name if hasattr(api_album, 'name') else str(api_album)
+ for db_name in db_album_names:
+ score = matching.similarity_score(
+ matching.normalize_string(api_name),
+ matching.normalize_string(db_name)
+ )
+ if score >= self.album_match_threshold:
+ logger.debug(f" {source_name}: matched '{artist.name}' via album '{api_name}' ↔ '{db_name}' (score={score:.2f})")
+ return discog
+
+ except Exception as e:
+ logger.debug(f" {source_name}: discography fetch failed for '{artist.name}': {e}")
+ continue
+
+ return None
+
+ @staticmethod
+ def _extract_year(album) -> Optional[str]:
+ """Extract a 4-digit year from an Album object's release_date."""
+ release_date = getattr(album, 'release_date', '') or ''
+ release_date = str(release_date)
+ if len(release_date) >= 4:
+ year = release_date[:4]
+ if year.isdigit() and int(year) > 1900:
+ return year
+ return None
+
+ # ── Album processing (batch, local DB only) ──
+
+ def _process_albums(self) -> int:
+ conn = None
+ try:
+ conn = self.db._get_connection()
+ cursor = conn.cursor()
+ cursor.execute("""
+ SELECT al.id, al.title, ar.name as artist_name
+ FROM albums al
+ JOIN artists ar ON ar.id = al.artist_id
+ WHERE (al.soul_id IS NULL OR al.soul_id = '')
+ AND al.title IS NOT NULL AND al.title != ''
+ AND ar.name IS NOT NULL AND ar.name != ''
+ AND al.id IS NOT NULL
+ LIMIT ?
+ """, (self.batch_size,))
+ rows = cursor.fetchall()
+ if not rows:
+ return 0
+
+ count = 0
+ for album_id, title, artist_name in rows:
+ if self.should_stop:
+ break
+ soul_id = generate_soul_id(artist_name, title)
+ if not soul_id:
+ soul_id = f'soul_unnamed_{album_id}'
+ cursor.execute(
+ "UPDATE albums SET soul_id = ? WHERE id = ? AND (soul_id IS NULL OR soul_id = '')",
+ (soul_id, album_id)
+ )
+ count += 1
+ self.current_item = f"Album: {artist_name} - {title}"
+
+ if count > 0:
+ conn.commit()
+ self.stats['albums_processed'] += count
+ logger.info(f"Generated soul IDs for {count} albums")
+ return count
+ except Exception as e:
+ logger.error(f"Error processing albums: {e}")
+ self.stats['errors'] += 1
+ if conn:
+ try:
+ conn.rollback()
+ except Exception:
+ pass
+ return 0
+ finally:
+ if conn:
+ conn.close()
+
+ # ── Track processing (batch, local DB only) ──
+
+ def _process_tracks(self) -> int:
+ conn = None
+ try:
+ conn = self.db._get_connection()
+ cursor = conn.cursor()
+ cursor.execute("""
+ SELECT t.id, t.title, ar.name as artist_name, al.title as album_title
+ FROM tracks t
+ JOIN artists ar ON ar.id = t.artist_id
+ LEFT JOIN albums al ON al.id = t.album_id
+ WHERE (t.soul_id IS NULL OR t.soul_id = '')
+ AND t.title IS NOT NULL AND t.title != ''
+ AND ar.name IS NOT NULL AND ar.name != ''
+ AND t.id IS NOT NULL
+ LIMIT ?
+ """, (self.batch_size,))
+ rows = cursor.fetchall()
+ if not rows:
+ return 0
+
+ count = 0
+ for track_id, title, artist_name, album_title in rows:
+ if self.should_stop:
+ break
+
+ # Song soul ID: artist + track (links singles to album versions)
+ song_soul_id = generate_soul_id(artist_name, title)
+
+ # Album track soul ID: artist + album + track (specific to this release)
+ album_soul_id = ''
+ if album_title:
+ album_soul_id = generate_soul_id(artist_name, album_title, title)
+
+ if not song_soul_id:
+ song_soul_id = f'soul_unnamed_{track_id}'
+ cursor.execute(
+ "UPDATE tracks SET soul_id = ?, album_soul_id = ? WHERE id = ? AND (soul_id IS NULL OR soul_id = '')",
+ (song_soul_id, album_soul_id or None, track_id)
+ )
+ count += 1
+ self.current_item = f"Track: {artist_name} - {title}"
+
+ if count > 0:
+ conn.commit()
+ self.stats['tracks_processed'] += count
+ logger.info(f"Generated soul IDs for {count} tracks")
+ return count
+ except Exception as e:
+ logger.error(f"Error processing tracks: {e}")
+ self.stats['errors'] += 1
+ if conn:
+ try:
+ conn.rollback()
+ except Exception:
+ pass
+ return 0
+ finally:
+ if conn:
+ conn.close()
+
+ # ── Migrations ──
+
+ def _migrate_artist_soul_ids(self):
+ """One-time reset: clear all artist soul IDs when algorithm changes.
+ Uses a versioned metadata flag to run only once per algorithm version."""
+ conn = None
+ try:
+ conn = self.db._get_connection()
+ cursor = conn.cursor()
+
+ cursor.execute("SELECT value FROM metadata WHERE key = 'soulid_artist_version' LIMIT 1")
+ row = cursor.fetchone()
+ if row and row[0] == 'debut_year_api_v2':
+ return # Already on latest version
+
+ # Reset all artist soul IDs for regeneration
+ cursor.execute("UPDATE artists SET soul_id = NULL WHERE soul_id IS NOT NULL")
+ reset_count = cursor.rowcount
+
+ # Mark current version
+ cursor.execute("INSERT OR REPLACE INTO metadata (key, value) VALUES ('soulid_artist_version', 'debut_year_api_v2')")
+ # Clean up old flags
+ cursor.execute("DELETE FROM metadata WHERE key IN ('soulid_artist_v2', 'soulid_artist_v3')")
+ conn.commit()
+
+ if reset_count > 0:
+ logger.info(f"SoulID migration: reset {reset_count} artist soul IDs for API-based debut year regeneration")
+ except Exception as e:
+ logger.error(f"SoulID migration failed: {e}")
+ if conn:
+ try:
+ conn.rollback()
+ except Exception:
+ pass
+ finally:
+ if conn:
+ conn.close()
+
+ # ── Helpers ──
+
+ def _count_pending(self) -> int:
+ conn = None
+ try:
+ conn = self.db._get_connection()
+ cursor = conn.cursor()
+ total = 0
+
+ # Must match the WHERE clauses in _process_* methods exactly
+ cursor.execute("""
+ SELECT COUNT(*) FROM artists
+ WHERE (soul_id IS NULL OR soul_id = '')
+ AND name IS NOT NULL AND name != ''
+ AND id IS NOT NULL
+ """)
+ total += (cursor.fetchone() or [0])[0]
+
+ cursor.execute("""
+ SELECT COUNT(*) FROM albums al
+ JOIN artists ar ON ar.id = al.artist_id
+ WHERE (al.soul_id IS NULL OR al.soul_id = '')
+ AND al.title IS NOT NULL AND al.title != ''
+ AND ar.name IS NOT NULL AND ar.name != ''
+ AND al.id IS NOT NULL
+ """)
+ total += (cursor.fetchone() or [0])[0]
+
+ cursor.execute("""
+ SELECT COUNT(*) FROM tracks t
+ JOIN artists ar ON ar.id = t.artist_id
+ WHERE (t.soul_id IS NULL OR t.soul_id = '')
+ AND t.title IS NOT NULL AND t.title != ''
+ AND ar.name IS NOT NULL AND ar.name != ''
+ AND t.id IS NOT NULL
+ """)
+ total += (cursor.fetchone() or [0])[0]
+
+ return total
+ except Exception:
+ return 0
+ finally:
+ if conn:
+ conn.close()
diff --git a/database/music_database.py b/database/music_database.py
index 010e2e05..0f91d775 100644
--- a/database/music_database.py
+++ b/database/music_database.py
@@ -356,6 +356,7 @@ class MusicDatabase:
self._add_profile_settings(cursor)
self._add_profile_listenbrainz_support(cursor)
self._add_profile_service_credentials(cursor)
+ self._add_soul_id_columns(cursor)
# Spotify library cache
self._add_spotify_library_cache_table(cursor)
@@ -2625,6 +2626,42 @@ class MusicDatabase:
except Exception as e:
logger.error(f"Error in per-profile service credentials migration: {e}")
+ def _add_soul_id_columns(self, cursor):
+ """Add soul_id columns to artists, albums, and tracks tables."""
+ try:
+ # Artists: soul_id
+ cursor.execute("PRAGMA table_info(artists)")
+ artist_cols = [c[1] for c in cursor.fetchall()]
+ if 'soul_id' not in artist_cols:
+ cursor.execute("ALTER TABLE artists ADD COLUMN soul_id TEXT DEFAULT NULL")
+ logger.info("Added soul_id column to artists table")
+
+ # Albums: soul_id
+ cursor.execute("PRAGMA table_info(albums)")
+ album_cols = [c[1] for c in cursor.fetchall()]
+ if 'soul_id' not in album_cols:
+ cursor.execute("ALTER TABLE albums ADD COLUMN soul_id TEXT DEFAULT NULL")
+ logger.info("Added soul_id column to albums table")
+
+ # Tracks: soul_id (song-level) + album_soul_id (release-specific)
+ cursor.execute("PRAGMA table_info(tracks)")
+ track_cols = [c[1] for c in cursor.fetchall()]
+ if 'soul_id' not in track_cols:
+ cursor.execute("ALTER TABLE tracks ADD COLUMN soul_id TEXT DEFAULT NULL")
+ logger.info("Added soul_id column to tracks table")
+ if 'album_soul_id' not in track_cols:
+ cursor.execute("ALTER TABLE tracks ADD COLUMN album_soul_id TEXT DEFAULT NULL")
+ logger.info("Added album_soul_id column to tracks table")
+
+ # Indexes for lookups
+ cursor.execute("CREATE INDEX IF NOT EXISTS idx_artists_soul_id ON artists (soul_id)")
+ cursor.execute("CREATE INDEX IF NOT EXISTS idx_albums_soul_id ON albums (soul_id)")
+ cursor.execute("CREATE INDEX IF NOT EXISTS idx_tracks_soul_id ON tracks (soul_id)")
+ cursor.execute("CREATE INDEX IF NOT EXISTS idx_tracks_album_soul_id ON tracks (album_soul_id)")
+
+ except Exception as e:
+ logger.error(f"Error adding soul_id columns: {e}")
+
def set_profile_spotify(self, profile_id: int, client_id: str, client_secret: str,
redirect_uri: str = '') -> bool:
"""Save Spotify API credentials for a profile (encrypted)."""
@@ -7138,6 +7175,7 @@ class MusicDatabase:
a.genius_url,
a.tidal_id,
a.qobuz_id,
+ a.soul_id,
COUNT(DISTINCT al.id) as album_count,
COUNT(DISTINCT t.id) as track_count
FROM artists a
@@ -7148,7 +7186,7 @@ class MusicDatabase:
WHERE {where_clause}
AND a.id = (SELECT MIN(a2.id) FROM artists a2
WHERE a2.name = a.name AND a2.server_source = a.server_source)
- GROUP BY a.id, a.name, a.thumb_url, a.genres, a.musicbrainz_id, a.spotify_artist_id, a.itunes_artist_id, a.deezer_id, a.audiodb_id, a.lastfm_url, a.genius_url, a.tidal_id, a.qobuz_id
+ GROUP BY a.id, a.name, a.thumb_url, a.genres, a.musicbrainz_id, a.spotify_artist_id, a.itunes_artist_id, a.deezer_id, a.audiodb_id, a.lastfm_url, a.genius_url, a.tidal_id, a.qobuz_id, a.soul_id
ORDER BY a.name COLLATE NOCASE
LIMIT ? OFFSET ?
"""
@@ -7200,6 +7238,7 @@ class MusicDatabase:
'genius_url': row['genius_url'],
'tidal_id': row['tidal_id'],
'qobuz_id': row['qobuz_id'],
+ 'soul_id': row['soul_id'],
'album_count': row['album_count'] or 0,
'track_count': row['track_count'] or 0,
'is_watched': bool(is_watched)
diff --git a/web_server.py b/web_server.py
index d7bdcc80..04978989 100644
--- a/web_server.py
+++ b/web_server.py
@@ -41343,6 +41343,37 @@ def hydrabase_worker_resume():
from core.repair_worker import RepairWorker
+# ===================================================================
+# SoulID Worker — generates deterministic soul IDs for library entities
+# ===================================================================
+soulid_worker = None
+try:
+ from core.soulid_worker import SoulIDWorker
+ from database.music_database import MusicDatabase
+ soulid_db = MusicDatabase()
+ soulid_worker = SoulIDWorker(database=soulid_db)
+ soulid_worker.start()
+ print("✅ SoulID worker initialized and started")
+except Exception as e:
+ print(f"⚠️ SoulID worker initialization failed: {e}")
+ soulid_worker = None
+
+@app.route('/api/soulid/status', methods=['GET'])
+def soulid_status():
+ """Get SoulID worker status for UI polling."""
+ try:
+ if soulid_worker is None:
+ return jsonify({
+ 'enabled': False, 'running': False, 'paused': False, 'idle': False,
+ 'current_item': None, 'stats': {}
+ })
+ return jsonify(soulid_worker.get_stats())
+ except Exception as e:
+ return jsonify({'error': str(e)}), 500
+
+# ===================================================================
+# Repair Worker — Library maintenance and repair jobs
+# ===================================================================
repair_worker = None
try:
from database.music_database import MusicDatabase
@@ -42858,6 +42889,7 @@ def _emit_enrichment_status_loop():
'tidal-enrichment': lambda: tidal_enrichment_worker,
'qobuz-enrichment': lambda: qobuz_enrichment_worker,
'hydrabase': lambda: hydrabase_worker,
+ 'soulid': lambda: soulid_worker,
'repair': lambda: repair_worker,
}
while True:
diff --git a/webui/index.html b/webui/index.html
index 65cd88fa..989f0c7d 100644
--- a/webui/index.html
+++ b/webui/index.html
@@ -546,6 +546,27 @@
+
+