audiolibrarian 0.17.0__tar.gz → 0.18.0__tar.gz

{audiolibrarian-0.17.0 → audiolibrarian-0.18.0}/.gitignore

@@ -6,6 +6,7 @@ MANIFEST
 __pycache__/
 .mypy_cache/
 .pytype/
+.scratch/
 .venv/
 audiolibrarian.egg-info/
 dist/
@@ -15,8 +16,6 @@ new_library/
 workdir/
 venv/
 
-NOTES.md
-
 # MkDocs build output
 site/
 .cache/

{audiolibrarian-0.17.0 → audiolibrarian-0.18.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: audiolibrarian
-Version: 0.17.0
+Version: 0.18.0
 Summary: Manage my audio library.
 Project-URL: Repository, https://github.com/toadstule/audiolibrarian
 Author-email: Steve Jibson <steve@jibson.com>

{audiolibrarian-0.17.0 → audiolibrarian-0.18.0}/docs/api/audiolibrarian.md

@@ -31,7 +31,7 @@
 from audiolibrarian import AudioLibrarian
 
 # Initialize with custom config
-al = AudioLibrarian(config_path="custom_config.yaml")
+al = AudioLibrarian(config_path="custom_config.toml")
 
 # Scan a directory
 al.scan("/path/to/music")

{audiolibrarian-0.17.0 → audiolibrarian-0.18.0}/docs/user-guide/changelog.md

@@ -5,6 +5,17 @@ All notable changes to this project will be documented in this file.
 The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.0.0/),
 and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
 
+## [0.18.0] - 2025-06-27
+
+### Added
+
+- New `config` command to view and manage configuration
+- Support for tilde (`~`) in configuration file paths
+
+### Changed
+
+- Switched from YAML to TOML for configuration files
+
 ## [0.17.0] - 2025-06-22
 
 ### Added

{audiolibrarian-0.17.0 → audiolibrarian-0.18.0}/docs/user-guide/configuration.md

@@ -20,35 +20,37 @@ export AUDIOLIBRARIAN__MUSICBRAINZ__USERNAME="your_username"
 export AUDIOLIBRARIAN__MUSICBRAINZ__PASSWORD="your_password"
 ```
 
-### 2. YAML Configuration File (medium precedence)
+### 2. TOML Configuration File (medium precedence)
 
-- **Default location**: `~/.config/audiolibrarian/config.yaml`
+- **Default location**: `~/.config/audiolibrarian/config.toml`
 - **Example**:
 
-```yaml
+```toml
 # Base directory for your music library
-library_dir: "~/music/library"
+library_dir = "~/music/library"
 
 # Cache and working directory
-work_dir: "~/.cache/audiolibrarian"
+work_dir = "~/.cache/audiolibrarian"
 
-# CD/DVD device path (use null for default device)
-discid_device: null
+# CD/DVD device path (use empty string for default device)
+discid_device = ""
 
 # Audio normalization settings
-normalize:
-  normalizer: "auto"  # "auto", "wavegain", "ffmpeg", or "none"
-  ffmpeg:
-    target_level: -13  # Target LUFS level for ffmpeg normalization
-  wavegain:
-    gain: 5  # dB gain for wavegain normalization (0-10)
-    preset: "radio"  # "album" or "radio"
+[normalize]
+normalizer = "auto"  # "auto", "wavegain", "ffmpeg", or "none"
+
+[normalize.ffmpeg]
+target_level = -13  # Target LUFS level for ffmpeg normalization
+
+[normalize.wavegain]
+gain = 5  # dB gain for wavegain normalization (0-10)
+preset = "radio"  # "album" or "radio"
 
 # MusicBrainz API settings (optional)
-musicbrainz:
-  username: "your_username"  # For personal genre preferences
-  password: "your_password"  # Will be stored securely
-  rate_limit: 1.5  # Seconds between API requests
+[musicbrainz]
+username = "your_username"  # For personal genre preferences
+password = "your_password"  # Will be stored securely
+rate_limit = 1.5  # Seconds between API requests
 ```
 
 ### 3. Default Values (lowest precedence)
@@ -61,7 +63,7 @@ musicbrainz:
 |---------------------------------|------------------|-------------------------------------------|
 | `library_dir`                   | `./library`      | Directory for storing audio files         |
 | `work_dir`                      | (see below)[^wd] | Directory for temporary files             |
-| `discid_device`                 | `null`           | CD device path (null for default device)  |
+| `discid_device`                 | ``               | CD device path (null for default device)  |
 | `normalize.normalizer`          | `"auto"`         | "auto", "wavegain", "ffmpeg", or "none"   |
 | `normalize.ffmpeg.target_level` | `-13`            | Target LUFS level (ffmpeg)                |
 | `normalize.wavegain.gain`       | `5`              | Normalization gain in dB (0-10, wavegain) |

{audiolibrarian-0.17.0 → audiolibrarian-0.18.0}/pyproject.toml

@@ -13,6 +13,7 @@ dev = [
     "pymarkdownlnt",
     "pytest",
     "pytest-env",
+    "pytest-mock",
     "ruff",
     "types-pyyaml",
     "types-requests",
@@ -49,7 +50,7 @@ readme = "README.md"
 requires-python = ">=3.12,<3.14"
 
 [project.scripts]
-audiolibrarian = "audiolibrarian:cli.main"
+audiolibrarian = "audiolibrarian.entrypoints.cli:main"
 
 [project.urls]
 Repository = "https://github.com/toadstule/audiolibrarian"
@@ -86,6 +87,7 @@ ignore_errors = true  # This is not our code.
 [tool.pymarkdown]
 plugins.md013.line_length = 100
 plugins.md013.code_block_line_length = 100
+plugins.md024.enabled = false
 #plugins.md007.enabled = true
 #plugins.md007.code_block_line_length = 160
 

{audiolibrarian-0.17.0 → audiolibrarian-0.18.0}/src/audiolibrarian/__init__.py

@@ -16,4 +16,4 @@
 #  You should have received a copy of the GNU General Public License along with audiolibrarian.
 #  If not, see <https://www.gnu.org/licenses/>.
 #
-__version__ = "0.17.0"
+__version__ = "0.18.0"

{audiolibrarian-0.17.0 → audiolibrarian-0.18.0}/src/audiolibrarian/audiosource.py

@@ -27,8 +27,7 @@ from collections.abc import Callable  # noqa: TC003
 
 import discid
 
-from audiolibrarian import audiofile, records, sh, text
-from audiolibrarian.settings import SETTINGS
+from audiolibrarian import audiofile, config, records, sh, text
 
 log = logging.getLogger(__name__)
 
@@ -93,10 +92,10 @@ class AudioSource(abc.ABC):
 class CDAudioSource(AudioSource):
     """AudioSource from a compact disc."""
 
-    def __init__(self) -> None:
+    def __init__(self, settings: config.Settings) -> None:
         """Initialize a CDAudioSource."""
         super().__init__()
-        self._cd = discid.read(SETTINGS.discid_device, features=["mcn"])
+        self._cd = discid.read(settings.discid_device or None, features=["mcn"])
 
     def get_search_data(self) -> dict[str, str]:
         """Return a dictionary of search data useful for doing a MusicBrainz search."""

{audiolibrarian-0.17.0 → audiolibrarian-0.18.0}/src/audiolibrarian/base.py

@@ -23,19 +23,25 @@ import argparse
 import logging
 import pathlib
 import shutil
-import subprocess
 import sys
 import warnings
 from collections.abc import Iterable
 from typing import Any, Final
 
 import colors
-import ffmpeg_normalize
 import filelock
 import yaml
 
-from audiolibrarian import audiofile, audiosource, musicbrainz, records, sh, text
-from audiolibrarian.settings import SETTINGS
+from audiolibrarian import (
+    audiofile,
+    audiosource,
+    config,
+    musicbrainz,
+    normalizer,
+    records,
+    sh,
+    text,
+)
 
 log = logging.getLogger(__name__)
 
@@ -49,8 +55,9 @@ class Base:
     command: str | None = None
     _manifest_file: Final[str] = "Manifest.yaml"
 
-    def __init__(self, args: argparse.Namespace) -> None:
+    def __init__(self, args: argparse.Namespace, settings: config.Settings) -> None:
         """Initialize the base."""
+        self._settings = settings
         # Pull in stuff from args.
         search_keys = ("album", "artist", "mb_artist_id", "mb_release_id")
         self._provided_search_data = {k: v for k, v in vars(args).items() if k in search_keys}
@@ -60,8 +67,8 @@ class Base:
             self._disc_number, self._disc_count = 1, 1
 
         # Directories.
-        self._library_dir = SETTINGS.library_dir
-        self._work_dir = SETTINGS.work_dir
+        self._library_dir = self._settings.library_dir
+        self._work_dir = self._settings.work_dir
         self._flac_dir = self._work_dir / "flac"
         self._m4a_dir = self._work_dir / "m4a"
         self._mp3_dir = self._work_dir / "mp3"
@@ -70,7 +77,7 @@ class Base:
 
         self._lock = filelock.FileLock(str(self._work_dir) + ".lock")
 
-        self._normalizer = self._which_normalizer()
+        self._normalizer = normalizer.Normalizer.factory(self._settings.normalize)
 
         # Initialize stuff that will be defined later.
         self._audio_source: audiosource.AudioSource | None = None
@@ -143,7 +150,7 @@ class Base:
         search_data: dict[str, str] = (
             self._audio_source.get_search_data() if self._audio_source is not None else {}
         )
-        searcher = musicbrainz.Searcher(**search_data)  # type: ignore[arg-type]
+        searcher = musicbrainz.Searcher(settings=self._settings.musicbrainz, **search_data)  # type: ignore[arg-type]
         searcher.disc_number = str(self._disc_number)
         # Override with user-provided info.
         if value := self._provided_search_data.get("artist"):
@@ -269,35 +276,7 @@ class Base:
 
     def _normalize(self) -> None:
         """Normalize the wav files using the selected normalizer."""
-        if self._normalizer == "none":
-            return
-        print(f"Normalizing wav files using {self._normalizer}...")
-
-        if self._normalizer == "wavegain":
-            command = [
-                "wavegain",
-                f"--{SETTINGS.normalize.wavegain.preset}",
-                f"--gain={SETTINGS.normalize.wavegain.gain}",
-                "--apply",
-            ]
-            command.extend(str(f) for f in self._wav_filenames)
-            result = subprocess.run(command, capture_output=True, check=False)  # noqa: S603
-            for line in str(result.stderr).split(r"\n"):
-                line_trunc = line[:137] + "..." if len(line) > 140 else line  # noqa: PLR2004
-                log.info("WAVEGAIN: %s", line_trunc)
-            result.check_returncode()
-            return
-
-        normalizer = ffmpeg_normalize.FFmpegNormalize(
-            extension="wav",
-            keep_loudness_range_target=True,
-            target_level=SETTINGS.normalize.ffmpeg.target_level,
-        )
-        for wav_file in self._wav_filenames:
-            normalizer.add_media_file(str(wav_file), str(wav_file))
-        log.info("NORMALIZER: starting ffmpeg normalization...")
-        normalizer.run_normalization()
-        log.info("NORMALIZER: ffmpeg normalization completed successfully")
+        self._normalizer.normalize(set(self._wav_filenames))
 
     def _rename_wav(self) -> None:
         """Rename the wav files to a filename-sane representation of the track title."""
@@ -428,34 +407,6 @@ class Base:
             yaml.dump(manifest, manifest_file)
         print(f"Wrote {manifest_filename}")
 
-    @staticmethod
-    def _which_normalizer() -> str:
-        """Determine which normalizer to use based on settings and availability.
-
-        Returns:
-            str: The name of the normalizer to use ("wavegain", "ffmpeg" or "none")
-        """
-        normalizer = SETTINGS.normalize.normalizer
-        if normalizer == "none":
-            return "none"
-
-        wavegain_found = shutil.which("wavegain")
-        if normalizer in ("auto", "wavegain") and wavegain_found:
-            return "wavegain"
-
-        ffmpeg_found = shutil.which("ffmpeg")
-        if normalizer in ("auto", "ffmpeg") and ffmpeg_found:
-            return "ffmpeg"
-
-        if wavegain_found:
-            log.warning("ffmpeg not found, using wavegain for normalization")
-            return "wavegain"
-        if ffmpeg_found:
-            log.warning("wavegain not found, using ffmpeg for normalization")
-            return "ffmpeg"
-        log.warning("wavegain not found, ffmpeg not found, using no normalization")
-        return "none"
-
     @staticmethod
     def _find_audio_files(directories: list[str | pathlib.Path]) -> Iterable[audiofile.AudioFile]:
         """Yield audiofile objects found in the given directories."""

{audiolibrarian-0.17.0 → audiolibrarian-0.18.0}/src/audiolibrarian/commands.py

@@ -22,7 +22,7 @@ import pathlib
 import re
 from typing import Any
 
-from audiolibrarian import __version__, audiofile, audiosource, base, genremanager
+from audiolibrarian import __version__, audiofile, audiosource, base, config, genremanager
 
 log = logging.getLogger(__name__)
 
@@ -39,6 +39,46 @@ class _Command:
         return True
 
 
+class Config(_Command, base.Base):
+    """AudioLibrarian tool for working with a config file.
+
+    This class performs all of its tasks on instantiation and provides no public members or
+    methods.
+    """
+
+    command = "config"
+    help = "work with the config file"
+    parser = argparse.ArgumentParser(description="Manage AudioLibrarian configuration")
+    parser.add_argument(
+        "--init",
+        "-i",
+        action="store_true",
+        help="initialize a new config file if it doesn't exist",
+    )
+
+    def __init__(self, args: argparse.Namespace, settings: config.Settings) -> None:
+        """Initialize a Config command handler."""
+        super().__init__(args, settings)
+
+        if args.init:
+            try:
+                config.init_config_file()
+            except FileExistsError as e:
+                msg = f"Config file already exists at {config.CONFIG_PATH}"
+                raise SystemExit(msg) from e
+            except Exception:
+                log.exception("Error creating config file")
+                raise
+            print(f"Created new config file at {config.CONFIG_PATH}")
+        else:
+            print(f"Config file location: {config.CONFIG_PATH}")
+            if config.CONFIG_PATH.exists():
+                print("\n=== Config file contents ===")
+                print(config.CONFIG_PATH.read_text(encoding="utf-8"))
+            else:
+                print("Config file does not exist. Use '--init' to create it.")
+
+
 class Convert(_Command, base.Base):
     """AudioLibrarian tool for converting and tagging audio files.
 
@@ -56,9 +96,9 @@ class Convert(_Command, base.Base):
     parser.add_argument("--disc", "-d", help="format: x/y: disc x of y for multi-disc release")
     parser.add_argument("filename", nargs="+", help="directory name or audio file name")
 
-    def __init__(self, args: argparse.Namespace) -> None:
+    def __init__(self, args: argparse.Namespace, settings: config.Settings) -> None:
         """Initialize a Convert command handler."""
-        super().__init__(args)
+        super().__init__(args, settings)
         self._source_is_cd = False
         self._audio_source = audiosource.FilesAudioSource([pathlib.Path(x) for x in args.filename])
         self._get_tag_info()
@@ -88,9 +128,9 @@ class Genre(_Command):
     parser_action.add_argument("--tag", action="store_true", help="update tags")
     parser_action.add_argument("--update", action="store_true", help="update MusicBrainz")
 
-    def __init__(self, args: argparse.Namespace) -> None:
+    def __init__(self, args: argparse.Namespace, settings: config.Settings) -> None:
         """Initialize a Genre command handler."""
-        genremanager.GenreManager(args)
+        genremanager.GenreManager(args=args, settings=settings.musicbrainz)
 
 
 class Manifest(_Command, base.Base):
@@ -111,9 +151,9 @@ class Manifest(_Command, base.Base):
     parser.add_argument("--disc", "-d", help="format: x/y: disc x of y for multi-disc release")
     parser.add_argument("filename", nargs="+", help="directory name or audio file name")
 
-    def __init__(self, args: argparse.Namespace) -> None:
+    def __init__(self, args: argparse.Namespace, settings: config.Settings) -> None:
         """Initialize a Manifest command handler."""
-        super().__init__(args)
+        super().__init__(args, settings)
         self._source_is_cd = args.cd
         self._audio_source = audiosource.FilesAudioSource([pathlib.Path(x) for x in args.filename])
         source_filenames = self._audio_source.get_source_filenames()
@@ -139,9 +179,9 @@ class Reconvert(_Command, base.Base):
     parser = argparse.ArgumentParser()
     parser.add_argument("directories", nargs="+", help="source directories")
 
-    def __init__(self, args: argparse.Namespace) -> None:
+    def __init__(self, args: argparse.Namespace, settings: config.Settings) -> None:
         """Initialize a Reconvert command handler."""
-        super().__init__(args)
+        super().__init__(args, settings)
         self._source_is_cd = False
         manifest_paths = self._find_manifests(args.directories)
         count = len(manifest_paths)
@@ -172,9 +212,9 @@ class Rename(_Command, base.Base):
     parser.add_argument("--dry-run", action="store_true", help="don't actually rename files")
     parser.add_argument("directories", nargs="+", help="audio file directories")
 
-    def __init__(self, args: argparse.Namespace) -> None:
+    def __init__(self, args: argparse.Namespace, settings: config.Settings) -> None:
         """Initialize a Rename command handler."""
-        super().__init__(args)
+        super().__init__(args, settings)
         self._source_is_cd = False
         print("Finding audio files...")
         for audio_file in self._find_audio_files(args.directories):
@@ -233,11 +273,11 @@ class Rip(_Command, base.Base):
     parser.add_argument("--mb-release-id", help="MusicBrainz release ID")
     parser.add_argument("--disc", "-d", help="x/y: disc x of y; multi-disc release")
 
-    def __init__(self, args: argparse.Namespace) -> None:
+    def __init__(self, args: argparse.Namespace, settings: config.Settings) -> None:
         """Initialize a Rip command handler."""
-        super().__init__(args)
+        super().__init__(args, settings)
         self._source_is_cd = True
-        self._audio_source = audiosource.CDAudioSource()
+        self._audio_source = audiosource.CDAudioSource(settings)
         self._get_tag_info()
         self._convert()
         self._write_manifest()
@@ -254,9 +294,10 @@ class Version(_Command):
     command = "version"
     help = "display the program version"
 
-    def __init__(self, args: argparse.Namespace) -> None:
+    def __init__(self, args: argparse.Namespace, settings: config.Settings) -> None:
         """Initialize a Version command handler."""
-        _ = args
+        _, _ = args, settings
+        del args, settings  # Unused.
         print(f"audiolibrarian {__version__}")
 
 
@@ -280,4 +321,4 @@ def _validate_disc_arg(args: argparse.Namespace) -> bool:
     return True
 
 
-COMMANDS: set[Any] = {Convert, Genre, Manifest, Reconvert, Rename, Rip, Version}
+COMMANDS: set[Any] = {Config, Convert, Genre, Manifest, Reconvert, Rename, Rip, Version}

audiolibrarian-0.17.0/src/audiolibrarian/settings.py → audiolibrarian-0.18.0/src/audiolibrarian/config.py

@@ -7,8 +7,8 @@ sources of configuration:
    - Prefix: "AUDIOLIBRARIAN__"
    - Nested fields: Use "__" as delimiter (e.g., AUDIOLIBRARIAN__MUSICBRAINZ__USERNAME)
 
-2. YAML Configuration File:
-   - Location: $XDG_CONFIG_HOME/audiolibrarian/config.yaml
+2. TOML Configuration File:
+   - Location: $XDG_CONFIG_HOME/audiolibrarian/config.toml
    - Supports nested structure for MusicBrainz settings
 
 3. Default Values:
@@ -39,37 +39,51 @@ Sensitive fields (like passwords) are handled using pydantic.SecretStr for secur
 #
 import logging
 import pathlib
-from typing import Literal
+from typing import Annotated, Final, Literal
 
 import pydantic
 import pydantic_settings
 import xdg_base_dirs
 
+CONFIG_PATH: Final[pathlib.Path] = (
+    xdg_base_dirs.xdg_config_home() / "audiolibrarian" / "config.toml"
+)
+
 logger = logging.getLogger(__name__)
 
+ExpandedPath = Annotated[
+    pathlib.Path,
+    pydantic.AfterValidator(lambda v: v.expanduser()),
+]
+
+
+class EmptySettings(pydantic.BaseModel):
+    """Empty settings."""
 
-class MusicBrainzSettings(pydantic_settings.BaseSettings):
+
+class MusicBrainzSettings(pydantic.BaseModel):
     """Configuration settings for MusicBrainz."""
 
     password: pydantic.SecretStr = pydantic.SecretStr("")
     username: str = ""
     rate_limit: pydantic.PositiveFloat = 1.5  # Seconds between requests.
+    work_dir: ExpandedPath = xdg_base_dirs.xdg_cache_home() / "audiolibrarian"
 
 
-class NormalizeFFmpegSettings(pydantic_settings.BaseSettings):
+class NormalizeFFmpegSettings(pydantic.BaseModel):
     """Configuration settings for ffmpeg normalization."""
 
     target_level: float = -13
 
 
-class NormalizeWavegainSettings(pydantic_settings.BaseSettings):
+class NormalizeWavegainSettings(pydantic.BaseModel):
     """Configuration settings for wavegain normalization."""
 
     gain: int = 5  # dB
     preset: Literal["album", "radio"] = "radio"
 
 
-class NormalizeSettings(pydantic_settings.BaseSettings):
+class NormalizeSettings(pydantic.BaseModel):
     """Configuration settings for audio normalization."""
 
     normalizer: Literal["auto", "wavegain", "ffmpeg", "none"] = "auto"
@@ -80,16 +94,16 @@ class NormalizeSettings(pydantic_settings.BaseSettings):
 class Settings(pydantic_settings.BaseSettings):
     """Configuration settings for AudioLibrarian."""
 
-    discid_device: str | None = None  # Use default device.
-    library_dir: pathlib.Path = pathlib.Path("library").resolve()
+    discid_device: str = ""  # Use default device.
+    library_dir: ExpandedPath = pathlib.Path("library").resolve()
     musicbrainz: MusicBrainzSettings = MusicBrainzSettings()
     normalize: NormalizeSettings = NormalizeSettings()
-    work_dir: pathlib.Path = xdg_base_dirs.xdg_cache_home() / "audiolibrarian"
+    work_dir: ExpandedPath = xdg_base_dirs.xdg_cache_home() / "audiolibrarian"
 
     model_config = pydantic_settings.SettingsConfigDict(
         env_nested_delimiter="__",
         env_prefix="AUDIOLIBRARIAN__",
-        yaml_file=str(xdg_base_dirs.xdg_config_home() / "audiolibrarian" / "config.yaml"),
+        toml_file=str(CONFIG_PATH),
         frozen=True,  # Make settings immutable.
     )
 
@@ -102,13 +116,37 @@ class Settings(pydantic_settings.BaseSettings):
         dotenv_settings: pydantic_settings.PydanticBaseSettingsSource,
         file_secret_settings: pydantic_settings.PydanticBaseSettingsSource,
     ) -> tuple[pydantic_settings.PydanticBaseSettingsSource, ...]:
+        """Customize settings sources."""
         del dotenv_settings, file_secret_settings  # Unused.
         return (
+            init_settings,  # Used for tests.
             env_settings,
-            pydantic_settings.YamlConfigSettingsSource(settings_cls),
-            init_settings,
+            pydantic_settings.TomlConfigSettingsSource(settings_cls),
         )
 
 
-SETTINGS = Settings()
-__all__ = ["SETTINGS"]
+def init_config_file() -> None:
+    """Initialize a new config file with default values.
+
+    The config file will be created at the location specified by CONFIG_PATH.
+    If the parent directory doesn't exist, it will be created.
+
+    Raises:
+        FileExistsError: If the config file already exists
+        OSError: If there's an error creating the file or directories
+        FileNotFoundError: If the template file cannot be found
+    """
+    if CONFIG_PATH.exists():
+        msg = f"Config file already exists at {CONFIG_PATH}"
+        logger.warning(msg)
+        raise FileExistsError(msg)
+
+    # Create the config directory if it doesn't exist
+    CONFIG_PATH.parent.mkdir(parents=True, exist_ok=True)
+
+    # Get the directory where this file is located
+    template_dir = pathlib.Path(__file__).parent / "templates"
+    template_file = template_dir / CONFIG_PATH.name
+
+    # Read the template and write to the config file
+    CONFIG_PATH.write_text(template_file.read_text(encoding="utf-8"), encoding="utf-8")

audiolibrarian-0.18.0/src/audiolibrarian/entrypoints/__init__.py

@@ -0,0 +1,17 @@
+"""Entrypoints for audiolibrarian."""
+#
+#  Copyright (c) 2000-2025 Stephen Jibson
+#
+#  This file is part of audiolibrarian.
+#
+#  Audiolibrarian is free software: you can redistribute it and/or modify it under the terms of the
+#  GNU General Public License as published by the Free Software Foundation, either version 3 of the
+#  License, or (at your option) any later version.
+#
+#  Audiolibrarian is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY;
+#  without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See
+#  the GNU General Public License for more details.
+#
+#  You should have received a copy of the GNU General Public License along with audiolibrarian.
+#  If not, see <https://www.gnu.org/licenses/>.
+#

{audiolibrarian-0.17.0/src/audiolibrarian → audiolibrarian-0.18.0/src/audiolibrarian/entrypoints}/cli.py

@@ -23,7 +23,7 @@ import subprocess
 import sys
 from typing import Final
 
-from audiolibrarian import commands
+from audiolibrarian import commands, config
 
 log = logging.getLogger("audiolibrarian")
 
@@ -57,7 +57,7 @@ class CommandLineInterface:
             if self._args.command == cmd.command:
                 if not cmd.validate_args(self._args):
                     sys.exit(2)
-                cmd(self._args)
+                cmd(self._args, config.Settings())
                 break
         if self._args.log_level == logging.DEBUG:
             print(pathlib.Path("/proc/self/status").read_text(encoding="utf-8"))

{audiolibrarian-0.17.0 → audiolibrarian-0.18.0}/src/audiolibrarian/genremanager.py

@@ -29,8 +29,7 @@ import mutagen.flac
 import mutagen.id3
 import mutagen.mp4
 
-from audiolibrarian import musicbrainz, text
-from audiolibrarian.settings import SETTINGS
+from audiolibrarian import config, musicbrainz, text
 
 log = logging.getLogger(__name__)
 
@@ -38,10 +37,11 @@ log = logging.getLogger(__name__)
 class GenreManager:
     """Manage genres."""
 
-    def __init__(self, args: argparse.Namespace) -> None:
+    def __init__(self, args: argparse.Namespace, settings: config.MusicBrainzSettings) -> None:
         """Initialize a GenreManager instance."""
         self._args = args
-        self._mb = musicbrainz.MusicBrainzSession()
+        self._settings = settings
+        self._mb = musicbrainz.MusicBrainzSession(settings=settings)
         self._paths = self._get_all_paths()
         self._paths_by_artist = self._get_paths_by_artist()
         _u, _c = self._get_genres_by_artist()
@@ -149,7 +149,7 @@ class GenreManager:
         user: dict[str, str] = {}
         community: dict[str, dict[str, Any]] = {}
         user_modified = False
-        cache_file = SETTINGS.work_dir / "user-genres.pickle"
+        cache_file = self._settings.work_dir / "user-genres.pickle"
         if cache_file.exists():
             with cache_file.open(mode="rb") as cache_file_obj:
                 user = pickle.load(cache_file_obj)  # noqa: S301