Replace vendored musicbrainzngs with wnpmb package

Drop Python 3.10 support; minimum version is now Python 3.11
(required by wnpmb).

**MusicBrainz client overhaul**
Remove the vendored musicbrainzngs library (XML/aiohttp-based),
the custom client.py (~420 lines), and parser.py (~340 lines).
Replace with wnpmb — a JSON/httpx async MusicBrainz client —
installed as a direct package dependency. helper.py rewritten to
use wnpmb's API directly.

**Release and recording selection improvements**
wnpmb's select_best_release scores studio albums over singles/EPs,
so album metadata is now more authoritative. find_recording() now
receives a year hint (extracted via get_best_year(), which prefers
originalyear > date > year) for better disambiguation of same-titled
recordings across eras. artistwebsites moved out of the cached
recording payload (config-dependent, must be computed fresh).

**Discogs URL injection fix**
Restore original gate logic: inject Discogs URL from MB artist
relations when discogs/enabled OR musicbrainz/discogs is set.
Migration had changed this to musicbrainz/discogs only, silently
dropping URLs for users with Discogs enabled.

**apicache event loop fix**
asyncio.Lock is bound to the event loop at creation time. Replace
the singleton lock with a property that recreates it when the
running loop changes, fixing test isolation failures under
per-function asyncio_mode.

**tinytag bpm/key fixes**
M4A stores bpm as a list where the first element may be a base64
float32 blob; scan the list for the first numeric string value.
M4A initial_key (standard musical key) now takes priority over key
(Serato internal code). Both fields unwrap list input correctly.

**New utility**
nowplaying/utils/metadata.py: get_best_year() centralises the
originalyear/date/year precedence logic used across helper.py and
processors.py.

**Tests**
Add unit tests for date normalisation, artist-in-title stripping,
bpm multi-value decoding, and key field priority. Update integration
tests to reflect improved release selection accuracy and correct
multi-artist field handling.

Author: aw-was-here

CHANGELOG.md

@@ -22,6 +22,10 @@
 
 * Developer Stuff
   * Dependency updates
+  * **Python 3.10 is no longer supported**; minimum version is now Python 3.11
+  * Replace vendored musicbrainzngs library with wnpmb package, removing ~3,500
+    lines of XML-based MusicBrainz client code in favour of a JSON/httpx async
+    client with improved release selection accuracy
 
 ## Version 5.1.0 - 2026-03-26
 

builder.sh

@@ -18,12 +18,12 @@ check_python_version() {
   pyver=$("${pybin}" --version 2>&1)
   pyver=${pyver#* }
   read -ra PY_VER <<< "${pyver}"
-  if [[ ${PY_VER[0]} -ne 3 || ${PY_VER[1]} -lt 10 ]]; then
-    echo "Python 3.10 or later is required (got ${pyver})."
+  if [[ ${PY_VER[0]} -ne 3 || ${PY_VER[1]} -lt 11 ]]; then
+    echo "Python 3.11 or later is required (got ${pyver})."
     exit 1
   fi
   if [[ ${PY_VER[1]} -ge 14 ]]; then
-    echo "Python 3.14+ is not yet supported (got ${pyver}). Use Python 3.10–3.13."
+    echo "Python 3.14+ is not yet supported (got ${pyver}). Use Python 3.11–3.13."
     exit 1
   fi
 }
@@ -41,7 +41,7 @@ if [[ "${SYSTEM}" == "dev" ]]; then
   esac
   PYTHONBIN="${PYTHONBIN:-$(command -v "${PYTHON}")}"
   if [[ -z "${PYTHONBIN}" ]]; then
-    echo "Error: '${PYTHON}' not found on PATH. Please install Python 3.10–3.13."
+    echo "Error: '${PYTHON}' not found on PATH. Please install Python 3.11–3.13."
     exit 1
   fi
   check_python_version "${PYTHONBIN}"

nowplaying/apicache.py

@@ -59,6 +59,23 @@ class APIResponseCache:
         "CREATE INDEX IF NOT EXISTS idx_last_accessed ON api_responses(last_accessed);",
     ]
 
+    @property
+    def _lock(self) -> asyncio.Lock:
+        """Return an asyncio.Lock valid for the current event loop.
+
+        A new lock is created whenever the running loop changes — this keeps
+        tests that use per-function event loops from inheriting a stale lock
+        created by an earlier test's loop.
+        """
+        try:
+            current_loop: asyncio.AbstractEventLoop | None = asyncio.get_running_loop()
+        except RuntimeError:
+            current_loop = None
+        if self.__lock is None or self.__lock_loop is not current_loop:
+            self.__lock_loop = current_loop
+            self.__lock = asyncio.Lock()
+        return self.__lock
+
     def __init__(self, cache_dir: pathlib.Path | None = None):
         """Initialize the API cache.
 
@@ -74,7 +91,8 @@ def __init__(self, cache_dir: pathlib.Path | None = None):
 
         self.cache_dir.mkdir(parents=True, exist_ok=True)
         self.db_file = self.cache_dir / "api_responses.db"
-        self._lock = asyncio.Lock()
+        self.__lock: asyncio.Lock | None = None
+        self.__lock_loop: asyncio.AbstractEventLoop | None = None
 
         # Initialize database if needed
         self._init_task = asyncio.create_task(self._initialize_db())

nowplaying/bootstrap.py

@@ -14,9 +14,9 @@
 def verify_python_version():
     """make sure the correct version of python is being used"""
 
-    if sys.version_info[0] < 3 or (sys.version_info[0] == 3 and sys.version_info[1] < 10):
+    if sys.version_info[0] < 3 or (sys.version_info[0] == 3 and sys.version_info[1] < 11):
         msgbox = QErrorMessage()
-        msgbox.showMessage("Python Version must be 3.10 or higher.  Exiting.")
+        msgbox.showMessage("Python Version must be 3.11 or higher.  Exiting.")
         msgbox.show()
         msgbox.exec()
         return False
@@ -94,4 +94,7 @@ def setuplogging(
         level=logging.DEBUG,
     )
     logging.captureWarnings(True)
+    # httpx emits very noisy DEBUG-level connection tracing
+    logging.getLogger("httpx").setLevel(logging.WARNING)
+    logging.getLogger("httpcore").setLevel(logging.WARNING)
     return logpath

nowplaying/metadata/processors.py

@@ -111,14 +111,26 @@ async def getmoremetadata(  # pylint: disable=too-many-branches
                     self.metadata["artist"] = parts[0].strip()
                     self.metadata["title"] = parts[1].strip()
 
-        if (
-            " - " in self.metadata.get("title", "")
-            and self.metadata.get("artist")
-            and self.metadata["artist"] in self.metadata.get("title", "")
-        ):
-            logging.debug("Removing extra artist - from title")
-            parts = self.metadata["title"].split(" - ", 1)
-            self.metadata["title"] = parts[1].strip()
+        if " - " in self.metadata.get("title", "") and self.metadata.get("artist"):
+            artist = self.metadata["artist"]
+            title = self.metadata["title"]
+            if artist in title or artist.translate(nowplaying.utils.CUSTOM_TRANSLATE) in title:
+                logging.debug("Removing extra artist - from title")
+                parts = title.split(" - ", 1)
+                prefix = parts[0].strip()
+                self.metadata["title"] = parts[1].strip()
+                # If the prefix has a feat. component, append it to the current
+                # artist so MB search can match all credited artists.
+                # Preserve the existing (possibly non-ASCII) artist name so that
+                # wnpmb's arid-based Pass 0 still fires for non-Latin scripts.
+                for sep in [" feat.", " ft.", " featuring", " with "]:
+                    idx = prefix.lower().find(sep)
+                    if idx != -1:
+                        feat_part = prefix[idx:]
+                        new_artist = artist + feat_part
+                        logging.debug("Appending feat. to artist: %s", new_artist)
+                        self.metadata["artist"] = new_artist
+                        break
 
         await self._process_plugins(skipplugins)
 
@@ -154,6 +166,13 @@ def _fix_dates(self) -> None:
         if "date" in self.metadata and (not self.metadata["date"] or self.metadata["date"] == "0"):
             del self.metadata["date"]
 
+        if date := self.metadata.get("date"):
+            date = str(date)
+            if len(date) == 8 and date.isdigit():
+                self.metadata["date"] = f"{date[:4]}-{date[4:6]}-{date[6:]}"
+            elif len(date) == 6 and date.isdigit():
+                self.metadata["date"] = f"{date[:4]}-{date[4:]}"
+
     def _fix_duration(self) -> None:
         if not self.metadata or not self.metadata.get("duration"):
             return

nowplaying/metadata/tinytag_runner.py

@@ -246,12 +246,38 @@ def _detect_video_content(file_path: pathlib.Path) -> bool:  # pylint: disable=t
             )
             return False  # Still default to audio, but log as error for investigation
 
+    @staticmethod
+    def _decode_bpm(bpm_value) -> str | None:
+        """Extract a valid numeric BPM from a field value.
+
+        M4A files can have multiple 'bpm' atoms: a raw float32 binary blob
+        followed by the human-readable string (e.g. ['AAD8Qg==', '126']).
+        Return the first value that parses as a finite float.
+        """
+        if not bpm_value:
+            return None
+        values = bpm_value if isinstance(bpm_value, list) else [bpm_value]
+        for v in values:
+            try:
+                f = float(str(v))
+                if f > 0:
+                    return str(v)
+            except (ValueError, TypeError):
+                pass
+        return None
+
     @staticmethod
     def _decode_musical_key(key_value) -> str | None:
         """Decode musical key field, handling JSON structures from MixedInKey."""
         if not key_value:
             return None
 
+        # M4A custom atoms surface as a list; take the first element.
+        if isinstance(key_value, list):
+            key_value = key_value[0] if key_value else None
+        if not key_value:
+            return None
+
         key_str = str(key_value).strip()
 
         # Check if it looks like base64 encoded JSON
@@ -277,6 +303,7 @@ def _process_extra(self, extra: dict[str, object]) -> None:
             "acoustid id": "acoustidid",
             "bpm": "bpm",
             "isrc": "isrc",
+            "initial_key": "key",
             "key": "key",
             "composer": "composer",
             "lyricist": "lyricist",
@@ -300,9 +327,12 @@ def _process_extra(self, extra: dict[str, object]) -> None:
 
             if key in list_fields:
                 self._process_list_field(extra[key], newkey)
-            elif key == "key":
+            elif key in ("key", "initial_key"):
                 # Special handling for musical key field
                 self.metadata[newkey] = self._decode_musical_key(extra[key])
+            elif key == "bpm":
+                # M4A can store bpm as multiple atoms; pick the numeric one
+                self.metadata[newkey] = self._decode_bpm(extra[key])
             else:
                 self._process_single_field(extra[key], newkey)