Use context to share music_dir

Author: snejus

beets/context.py

@@ -0,0 +1,14 @@
+from contextvars import ContextVar
+
+# Holds the music dir context
+_music_dir_var: ContextVar[bytes] = ContextVar("music_dir", default=b"")
+
+
+def get_music_dir() -> bytes:
+    """Get the current music directory context."""
+    return _music_dir_var.get()
+
+
+def set_music_dir(value: bytes) -> None:
+    """Get the current music directory context."""
+    _music_dir_var.set(value)

beets/library/library.py

@@ -5,7 +5,7 @@
 import platformdirs
 
 import beets
-from beets import dbcore
+from beets import context, dbcore
 from beets.util import normpath
 
 from . import migrations
@@ -36,6 +36,7 @@ def __init__(
         super().__init__(path, timeout=timeout)
 
         self.directory = normpath(directory or platformdirs.user_music_path())
+        context.set_music_dir(self.directory)
 
         self.path_formats = path_formats
         self.replacements = replacements

beets/library/models.py

@@ -5,15 +5,14 @@
 import sys
 import time
 import unicodedata
-from contextlib import suppress
 from functools import cached_property
 from pathlib import Path
 from typing import TYPE_CHECKING, Any, ClassVar
 
 from mediafile import MediaFile, UnreadableFileError
 
 import beets
-from beets import dbcore, logging, plugins, util
+from beets import context, dbcore, logging, plugins, util
 from beets.dbcore import types
 from beets.util import (
     MoveOperation,
@@ -93,22 +92,16 @@ def _setitem(self, key: str, value: Any):
             # Store paths relative to the music directory
             # Check for absolute path because item may be initialised with
             # a relative path already
-            if os.path.isabs(value):
-                # Suppress these errors since tests may initialise an Item
-                # without the db attribute
-                with suppress(ValueError, AttributeError):
-                    value = os.path.relpath(value, self.db.directory)
+            if os.path.isabs(value) and (music_dir := context.get_music_dir()):
+                value = os.path.relpath(value, music_dir)
 
         return super()._setitem(key, value)
 
     def __getitem__(self, key: str):
         value = super().__getitem__(key)
         if key == "path" and value:
             # Return absolute paths.
-            # Suppress these errors since tests may initialise an Item
-            # without the db attribute
-            with suppress(ValueError, AttributeError):
-                value = os.path.join(self.db.directory, value)
+            value = normpath(os.path.join(context.get_music_dir(), value))
 
         return value
 

beets/util/__init__.py

@@ -16,6 +16,7 @@
 
 from __future__ import annotations
 
+import contextvars
 import errno
 import fnmatch
 import os
@@ -1048,17 +1049,15 @@ def asciify_path(path: str, sep_replace: str) -> str:
 
 
 def par_map(transform: Callable[[T], Any], items: Sequence[T]) -> None:
-    """Apply the function `transform` to all the elements in the
-    iterable `items`, like `map(transform, items)` but with no return
-    value.
+    """Apply a transformation to each item concurrently using a thread pool.
 
-    The parallelism uses threads (not processes), so this is only useful
-    for IO-bound `transform`s.
+    Propagates the calling thread's context variables into each worker,
+    ensuring that context-dependent state is available during parallel
+    execution.
     """
-    pool = ThreadPool()
-    pool.map(transform, items)
-    pool.close()
-    pool.join()
+    ctx = contextvars.copy_context()  # snapshot parent context at call time
+    with ThreadPool() as pool:
+        pool.map(lambda item: ctx.run(transform, item), items)
 
 
 class cached_classproperty(Generic[T]):

test/plugins/test_ipfs.py

@@ -37,7 +37,9 @@ def test_stored_hashes(self):
             try:
                 if check_item.get("ipfs", with_album=False):
                     ipfs_item = os.fsdecode(os.path.basename(want_item.path))
-                    want_path = f"/ipfs/{test_album.ipfs}/{ipfs_item}"
+                    want_path = os.path.normpath(
+                        f"/ipfs/{test_album.ipfs}/{ipfs_item}"
+                    )
                     want_path = bytestring_path(want_path)
                     assert check_item.path == want_path
                     assert (

test/test_query.py

@@ -310,6 +310,13 @@ def test_explicit(self, monkeypatch, lib, q, expected_titles):
 
         assert {i.title for i in lib.items(q)} == set(expected_titles)
 
+    def test_absolute(self, lib, helper):
+        q = f"path::{helper.lib_path / '/aaa/bb/c.mp3'}"
+
+        assert {i.title for i in lib.items(q)} == {"path item"}
+        item = lib.items(q)[0]
+        assert item._values_fixed["path"] == str(helper.lib_path / "/aaa/bb/c.mp3").encode()
+
     @pytest.mark.skipif(sys.platform == "win32", reason=WIN32_NO_IMPLICIT_PATHS)
     @pytest.mark.parametrize(
         "q, expected_titles",