audiometa-python 0.6.0__py3-none-any.whl

audiometa/test/helpers/riff/riff_metadata_setter.py

@@ -0,0 +1,374 @@
+"""RIFF metadata setting operations."""
+
+from pathlib import Path
+from typing import Any
+
+from ..common.external_tool_runner import ExternalMetadataToolError, run_external_tool
+
+
+class RIFFMetadataSetter:
+    """Static utility class for RIFF metadata setting using external tools."""
+
+    @staticmethod
+    def set_metadata(file_path: Path, metadata: dict[str, Any]) -> None:
+        """Set WAV metadata using bwfmetaedit tool."""
+        cmd = ["bwfmetaedit"]
+
+        # Map common metadata keys to bwfmetaedit arguments
+        key_mapping = {
+            "title": "--INAM",
+            "artist": "--IART",
+            "album": "--IPRD",
+            "genre": "--IGNR",
+            "date": "--ICRD",
+            "year": "--ICRD",
+            "release_date": "--ICRD",
+            "comment": "--ICMT",
+            "track": "--ITRK",
+            "track_number": "--ITRK",
+            "bpm": "--TBPM",
+            "composer": "--ICMP",
+            "lyrics": "--ILYR",
+            "language": "--ILNG",
+            "album_artist": "--IAAR",
+            "rating": "--IRTD",
+            "copyright": "--ICOP",
+            "isrc": "--ISRC",
+        }
+
+        # Handle list values - include first value in main command to avoid overwriting
+        artist_value = None
+        genre_value = None
+        composer_value = None
+        for key, value in metadata.items():
+            if isinstance(value, list) and value:
+                if key.lower() == "artist":
+                    artist_value = value[0]  # Store first artist for main command
+                elif key.lower() == "genre":
+                    genre_value = value[0]  # Store first genre for main command
+                elif key.lower() == "composer":
+                    composer_value = value[0]  # Store first composer for main command
+
+        # Handle non-list values and include list values in main command
+        # Note: Rating, BPM, Language, and Composer need to be set AFTER bwfmetaedit to avoid being overwritten
+        rating_value = None
+        bpm_value = None
+        language_value = None
+        composer_single_value = None
+        metadata_added = False
+        for key, value in metadata.items():
+            if key.lower() in key_mapping and not isinstance(value, list):
+                if key.lower() == "bpm":
+                    bpm_value = str(value)  # Store for later
+                elif key.lower() == "rating":
+                    rating_value = str(value)  # Store for later
+                elif key.lower() == "language":
+                    language_value = str(value)  # Store for later
+                elif key.lower() == "composer":
+                    composer_single_value = str(value)  # Store for later
+                else:
+                    cmd.extend([f"{key_mapping[key.lower()]}={value}"])
+                    metadata_added = True
+
+        # Add artist if it was provided as a list
+        if artist_value is not None:
+            cmd.extend([f"{key_mapping['artist']}={artist_value}"])
+            metadata_added = True
+
+        # Add genre if it was provided as a list
+        if genre_value is not None:
+            cmd.extend([f"{key_mapping['genre']}={genre_value}"])
+            metadata_added = True
+
+        # Run bwfmetaedit first if metadata was actually added
+        if metadata_added:
+            cmd.append(str(file_path))
+            run_external_tool(cmd, "bwfmetaedit")
+
+        # Set BPM, rating, and language AFTER bwfmetaedit to avoid being overwritten
+        if bpm_value is not None:
+            from .riff_manual_metadata_creator import ManualRIFFMetadataCreator
+
+            ManualRIFFMetadataCreator.create_bpm_field(file_path, bpm_value)
+
+        if rating_value is not None:
+            from .riff_manual_metadata_creator import ManualRIFFMetadataCreator
+
+            ManualRIFFMetadataCreator.create_rating_field(file_path, rating_value)
+
+        if language_value is not None:
+            from .riff_manual_metadata_creator import ManualRIFFMetadataCreator
+
+            ManualRIFFMetadataCreator.create_language_field(file_path, language_value)
+
+        # Set composer (from list or single value) AFTER bwfmetaedit
+        if composer_value is not None:
+            from .riff_manual_metadata_creator import ManualRIFFMetadataCreator
+
+            ManualRIFFMetadataCreator.create_composer_field(file_path, composer_value)
+        elif composer_single_value is not None:
+            from .riff_manual_metadata_creator import ManualRIFFMetadataCreator
+
+            ManualRIFFMetadataCreator.create_composer_field(file_path, composer_single_value)
+
+    @staticmethod
+    def set_comment(file_path: Path, comment: str) -> None:
+        command = ["bwfmetaedit", f"--ICMT={comment}", str(file_path)]
+        run_external_tool(command, "bwfmetaedit")
+
+    @staticmethod
+    def set_title(file_path: Path, title: str) -> None:
+        command = ["bwfmetaedit", f"--INAM={title}", str(file_path)]
+        run_external_tool(command, "bwfmetaedit")
+
+    @staticmethod
+    def set_multiple_titles(file_path: Path, titles: list[str], in_separate_frames: bool = False):
+        """Set multiple titles, optionally in separate INAM frames."""
+        if in_separate_frames:
+            from .riff_manual_metadata_creator import ManualRIFFMetadataCreator
+
+            ManualRIFFMetadataCreator.create_multiple_title_fields(file_path, titles)
+        # For now, just set the first title
+        elif titles:
+            command = ["bwfmetaedit", f"--INAM={titles[0]}", str(file_path)]
+            run_external_tool(command, "bwfmetaedit")
+
+    @staticmethod
+    def set_artist(file_path: Path, artist: str) -> None:
+        command = ["bwfmetaedit", f"--IART={artist}", str(file_path)]
+        run_external_tool(command, "bwfmetaedit")
+
+    @staticmethod
+    def set_album(file_path: Path, album: str) -> None:
+        command = ["bwfmetaedit", f"--IPRD={album}", str(file_path)]
+        run_external_tool(command, "bwfmetaedit")
+
+    @staticmethod
+    def set_genres(file_path: Path, genres: list[str]) -> None:
+        command = ["bwfmetaedit", f"--IGNR={','.join(genres)}", str(file_path)]
+        run_external_tool(command, "bwfmetaedit")
+
+    @staticmethod
+    def set_genre_text(file_path: Path, genre_text: str) -> None:
+        """Set RIFF genre using external exiftool or bwfmetaedit tool."""
+        try:
+            # Try exiftool first
+            RIFFMetadataSetter.set_riff_genre(file_path, genre_text)
+        except ExternalMetadataToolError:
+            try:
+                # Fallback to bwfmetaedit - split genre_text by semicolon and strip whitespace
+                genres = [genre.strip() for genre in genre_text.split(";") if genre.strip()]
+                RIFFMetadataSetter.set_genres(file_path, genres)
+            except ExternalMetadataToolError as e:
+                msg = f"Failed to set RIFF genre: {e}"
+                raise RuntimeError(msg) from e
+
+    @staticmethod
+    def set_lyrics(file_path: Path, lyrics: str) -> None:
+        from .riff_manual_metadata_creator import ManualRIFFMetadataCreator
+
+        ManualRIFFMetadataCreator.create_lyrics_field(file_path, lyrics)
+
+    @staticmethod
+    def set_language(file_path: Path, language: str) -> None:
+        import tempfile
+
+        with tempfile.NamedTemporaryFile(suffix=".wav", delete=False) as tmp_file:
+            tmp_path = Path(tmp_file.name)
+        try:
+            command = [
+                "ffmpeg",
+                "-i",
+                str(file_path),
+                "-c",
+                "copy",
+                "-metadata",
+                f"language={language}",
+                "-y",
+                str(tmp_path),
+            ]
+            run_external_tool(command, "ffmpeg")
+            tmp_path.replace(file_path)
+        finally:
+            if tmp_path.exists():
+                tmp_path.unlink()
+
+    @staticmethod
+    def set_max_metadata(file_path: Path) -> None:
+        from pathlib import Path
+
+        from ..common.external_tool_runner import run_script
+
+        scripts_dir = Path(__file__).parent.parent.parent.parent / "test" / "helpers" / "scripts"
+        run_script("set-riff-max-metadata.sh", file_path, scripts_dir)
+
+    @staticmethod
+    def set_riff_genre(file_path: Path, genre: str) -> None:
+        command = ["exiftool", "-overwrite_original", f"-Genre={genre}", str(file_path)]
+        run_external_tool(command, "exiftool")
+
+    @staticmethod
+    def set_artists(file_path: Path, artists: list[str], in_separate_frames: bool = False):
+        """Set multiple artists, optionally in separate IART frames."""
+        if in_separate_frames:
+            from .riff_manual_metadata_creator import ManualRIFFMetadataCreator
+
+            ManualRIFFMetadataCreator.create_multiple_artist_fields(file_path, artists)
+        # For testing multiple instances, we'd need to use a more sophisticated approach
+        # For now, just set the first artist
+        elif artists:
+            command = ["bwfmetaedit", f"--IART={artists[0]}", str(file_path)]
+            run_external_tool(command, "bwfmetaedit")
+
+    @staticmethod
+    def set_multiple_genres(file_path: Path, genres: list[str], in_separate_frames: bool = False):
+        """Set multiple genres, optionally in separate IGNR frames."""
+        if in_separate_frames:
+            from .riff_manual_metadata_creator import ManualRIFFMetadataCreator
+
+            ManualRIFFMetadataCreator.create_multiple_genre_fields(file_path, genres)
+        # For now, just set the first genre
+        elif genres:
+            command = ["bwfmetaedit", f"--IGNR={genres[0]}", str(file_path)]
+            run_external_tool(command, "bwfmetaedit")
+
+    @staticmethod
+    def set_multiple_composers(file_path: Path, composers: list[str], in_separate_frames: bool = False):
+        """Set multiple composers, optionally in separate ICMP frames."""
+        if in_separate_frames:
+            from .riff_manual_metadata_creator import ManualRIFFMetadataCreator
+
+            ManualRIFFMetadataCreator.create_multiple_composer_fields(file_path, composers)
+        # For now, just set the first composer
+        elif composers:
+            command = ["bwfmetaedit", f"--ICMP={composers[0]}", str(file_path)]
+            run_external_tool(command, "bwfmetaedit")
+
+    @staticmethod
+    def set_multiple_album_artists(file_path: Path, album_artists: list[str], _in_separate_frames: bool = False):
+        """Set multiple album artists, optionally in separate IAAR frames."""
+        # IAAR is not a standard RIFF INFO chunk field, so external tools don't support it.
+        # Use the manual metadata creator which can create non-standard RIFF fields.
+        from .riff_manual_metadata_creator import ManualRIFFMetadataCreator
+
+        ManualRIFFMetadataCreator.create_multiple_album_artist_fields(file_path, album_artists)
+
+    @staticmethod
+    def set_release_date(file_path: Path, release_date: str) -> None:
+        command = ["bwfmetaedit", f"--ICRD={release_date}", str(file_path)]
+        run_external_tool(command, "bwfmetaedit")
+
+    @staticmethod
+    def set_bext_description(file_path: Path, description: str) -> None:
+        """Set BWF bext Description field."""
+        command = ["bwfmetaedit", f"--Description={description}", str(file_path)]
+        run_external_tool(command, "bwfmetaedit")
+
+    @staticmethod
+    def set_bext_originator(file_path: Path, originator: str) -> None:
+        """Set BWF bext Originator field."""
+        command = ["bwfmetaedit", f"--Originator={originator}", str(file_path)]
+        run_external_tool(command, "bwfmetaedit")
+
+    @staticmethod
+    def set_bext_originator_reference(file_path: Path, originator_reference: str) -> None:
+        """Set BWF bext OriginatorReference field."""
+        command = ["bwfmetaedit", f"--OriginatorReference={originator_reference}", str(file_path)]
+        run_external_tool(command, "bwfmetaedit")
+
+    @staticmethod
+    def set_bext_origination_date(file_path: Path, origination_date: str) -> None:
+        """Set BWF bext OriginationDate field (YYYY-MM-DD format)."""
+        command = ["bwfmetaedit", f"--OriginationDate={origination_date}", str(file_path)]
+        run_external_tool(command, "bwfmetaedit")
+
+    @staticmethod
+    def set_bext_origination_time(file_path: Path, origination_time: str) -> None:
+        """Set BWF bext OriginationTime field (HH:MM:SS format)."""
+        command = ["bwfmetaedit", f"--OriginationTime={origination_time}", str(file_path)]
+        run_external_tool(command, "bwfmetaedit")
+
+    @staticmethod
+    def set_bext_time_reference(file_path: Path, time_reference: int) -> None:
+        """Set BWF bext TimeReference field."""
+        command = ["bwfmetaedit", f"--Timereference={time_reference}", str(file_path)]
+        run_external_tool(command, "bwfmetaedit")
+
+    @staticmethod
+    def set_bext_coding_history(file_path: Path, coding_history: str) -> None:
+        """Set BWF bext CodingHistory field."""
+        command = ["bwfmetaedit", f"--History={coding_history}", str(file_path)]
+        run_external_tool(command, "bwfmetaedit")
+
+    @staticmethod
+    def set_bext_metadata(file_path: Path, bext_metadata: dict[str, Any]) -> None:
+        """Set multiple BWF bext metadata fields at once.
+
+        Args:
+            file_path: Path to WAV file
+            bext_metadata: Dictionary with bext field names as keys:
+                - Description: str
+                - Originator: str
+                - OriginatorReference: str
+                - OriginationDate: str (YYYY-MM-DD format)
+                - OriginationTime: str (HH:MM:SS format)
+                - TimeReference: int (uint64)
+                - UMID: str (hex string)
+                - CodingHistory: str
+                - LoudnessValue: float (LU, converted to 0.1 LU units)
+                - LoudnessRange: float (LU, converted to 0.1 LU units)
+                - MaxTruePeakLevel: float (dB, converted to 0.1 dB units)
+                - MaxMomentaryLoudness: float (LU, converted to 0.1 LU units)
+                - MaxShortTermLoudness: float (LU, converted to 0.1 LU units)
+        """
+        # Map bext field names to bwfmetaedit arguments
+        field_mapping = {
+            "Description": "--Description",
+            "Originator": "--Originator",
+            "OriginatorReference": "--OriginatorReference",
+            "OriginationDate": "--OriginationDate",
+            "OriginationTime": "--OriginationTime",
+            "TimeReference": "--Timereference",
+            "UMID": "--UMID",
+            "CodingHistory": "--History",
+            "LoudnessValue": "--LoudnessValue",
+            "LoudnessRange": "--LoudnessRange",
+            "MaxTruePeakLevel": "--MaxTruePeakLevel",
+            "MaxMomentaryLoudness": "--MaxMomentaryLoudness",
+            "MaxShortTermLoudness": "--MaxShortTermLoudness",
+        }
+
+        # Separate loudness fields from other fields
+        # Loudness fields need to be set after other fields to ensure BWF v2 is created
+        loudness_fields = [
+            "LoudnessValue",
+            "LoudnessRange",
+            "MaxTruePeakLevel",
+            "MaxMomentaryLoudness",
+            "MaxShortTermLoudness",
+        ]
+        regular_fields = {}
+        loudness_metadata = {}
+
+        for field_name, value in bext_metadata.items():
+            if field_name in field_mapping and value is not None:
+                if field_name in loudness_fields:
+                    loudness_metadata[field_name] = value
+                else:
+                    regular_fields[field_name] = value
+
+        # Set regular fields first
+        if regular_fields:
+            cmd_regular = ["bwfmetaedit"]
+            for field_name, value in regular_fields.items():
+                cmd_regular.extend([f"{field_mapping[field_name]}={value}"])
+            cmd_regular.append(str(file_path))
+            run_external_tool(cmd_regular, "bwfmetaedit")
+
+        # Set loudness fields in separate command (ensures BWF v2 is properly created)
+        if loudness_metadata:
+            cmd_loudness = ["bwfmetaedit"]
+            for field_name, value in loudness_metadata.items():
+                cmd_loudness.extend([f"{field_mapping[field_name]}={value}"])
+            cmd_loudness.append(str(file_path))
+            run_external_tool(cmd_loudness, "bwfmetaedit")

audiometa/test/helpers/technical_info_inspector.py

@@ -0,0 +1,115 @@
+import subprocess
+from pathlib import Path
+
+
+class TechnicalInfoInspector:
+    """Helper class for inspecting technical audio file information using mediainfo."""
+
+    @staticmethod
+    def _run_mediainfo(file_path: str | Path, output_format: str = "JSON") -> dict:
+        """Run mediainfo on a file and return parsed output."""
+        cmd = ["mediainfo", f"--Output={output_format}", str(file_path)]
+        try:
+            result = subprocess.run(cmd, capture_output=True, text=True, check=True)
+            if output_format == "JSON":
+                import json
+
+                return json.loads(result.stdout)
+        except subprocess.CalledProcessError as e:
+            msg = f"Failed to run mediainfo on {file_path}: {e}"
+            raise RuntimeError(msg) from e
+        except json.JSONDecodeError as e:
+            msg = f"Failed to parse mediainfo output: {e}"
+            raise RuntimeError(msg) from e
+        else:
+            return {"text": result.stdout}
+
+    @staticmethod
+    def get_bitrate(file_path: str | Path) -> int | None:
+        """Get the bitrate of an audio file in kb/s using mediainfo."""
+        try:
+            data = TechnicalInfoInspector._run_mediainfo(file_path, "JSON")
+            tracks = data.get("media", {}).get("track", [])
+            for track in tracks:
+                if track.get("@type") == "Audio":
+                    bitrate_str = track.get("BitRate")
+                    if bitrate_str:
+                        # Handle formats like "128 kb/s" or "128000"
+                        if "kb/s" in str(bitrate_str):
+                            return int(str(bitrate_str).split()[0])
+                        if str(bitrate_str).isdigit():
+                            return int(bitrate_str) // 1000
+        except Exception:
+            return None
+        else:
+            return None
+
+    @staticmethod
+    def get_duration(file_path: str | Path) -> float | None:
+        """Get the duration of an audio file in seconds using mediainfo."""
+        try:
+            data = TechnicalInfoInspector._run_mediainfo(file_path, "JSON")
+            tracks = data.get("media", {}).get("track", [])
+            for track in tracks:
+                if track.get("@type") == "Audio":
+                    duration_str = track.get("Duration")
+                    if duration_str:
+                        # Handle formats like "1.025 s" or just numbers
+                        if "s" in duration_str:
+                            return float(duration_str.split()[0])
+                        return float(duration_str)
+        except Exception:
+            return None
+        else:
+            return None
+
+    @staticmethod
+    def get_sample_rate(file_path: str | Path) -> int | None:
+        """Get the sample rate of an audio file in Hz using mediainfo."""
+        try:
+            data = TechnicalInfoInspector._run_mediainfo(file_path, "JSON")
+            tracks = data.get("media", {}).get("track", [])
+            for track in tracks:
+                if track.get("@type") == "Audio":
+                    sample_rate_str = track.get("SamplingRate")
+                    if sample_rate_str:
+                        # Handle formats like "44100 Hz"
+                        if "Hz" in sample_rate_str:
+                            return int(sample_rate_str.split()[0])
+                        return int(sample_rate_str)
+        except Exception:
+            return None
+        else:
+            return None
+
+    @staticmethod
+    def get_channels(file_path: str | Path) -> int | None:
+        """Get the number of channels of an audio file using mediainfo."""
+        try:
+            data = TechnicalInfoInspector._run_mediainfo(file_path, "JSON")
+            tracks = data.get("media", {}).get("track", [])
+            for track in tracks:
+                if track.get("@type") == "Audio":
+                    channels_str = track.get("Channels")
+                    if channels_str:
+                        return int(channels_str)
+        except Exception:
+            return None
+        else:
+            return None
+
+    @staticmethod
+    def get_file_size(file_path: str | Path) -> int | None:
+        """Get the file size of an audio file in bytes using mediainfo."""
+        try:
+            data = TechnicalInfoInspector._run_mediainfo(file_path, "JSON")
+            tracks = data.get("media", {}).get("track", [])
+            for track in tracks:
+                if track.get("@type") == "General":
+                    file_size_str = track.get("FileSize")
+                    if file_size_str:
+                        return int(file_size_str)
+        except Exception:
+            return None
+        else:
+            return None

audiometa/test/helpers/temp_file_with_metadata.py

@@ -0,0 +1,82 @@
+"""Consolidated temporary file with metadata utilities for testing.
+
+This module provides a context manager for test files with metadata using contextlib.
+"""
+
+import tempfile
+from collections.abc import Generator
+from contextlib import contextmanager
+from pathlib import Path
+
+from .common import AudioFileCreator
+from .id3v1 import ID3v1MetadataSetter
+from .id3v2 import ID3v2MetadataSetter
+from .riff import RIFFMetadataSetter
+from .vorbis import VorbisMetadataSetter
+
+
+@contextmanager
+def temp_file_with_metadata(metadata: dict, format_type: str) -> Generator[Path, None, None]:
+    """Context manager for creating temporary test files with metadata.
+
+    This function creates a temporary audio file with the specified metadata,
+    yields its path for use in tests, and automatically cleans up the file.
+
+    Args:
+        metadata: Dictionary of metadata to set on the test file
+        format_type: Audio format ('mp3', 'id3v1', 'id3v2.3', 'id3v2.4', 'flac', 'wav')
+
+    Yields:
+        Path to the created test file with metadata
+
+    Example:
+        with temp_file_with_metadata({"title": "Test Song"}, "mp3") as test_file:
+            metadata = get_unified_metadata(test_file)
+    """
+    target_file = _create_test_file_with_metadata(metadata, format_type)
+    try:
+        yield target_file
+    finally:
+        if target_file.exists():
+            target_file.unlink()
+
+
+def _create_test_file_with_metadata(metadata: dict, format_type: str) -> Path:
+    """Create a test file with specific metadata values.
+
+    This function uses external tools to set specific metadata values
+    without using the app's update functions, improving test isolation.
+
+    Args:
+        metadata: Dictionary of metadata to set
+        format_type: Audio format ('mp3', 'id3v1', 'flac', 'wav')
+
+    Returns:
+        Path to the created file with metadata
+    """
+    # Create temporary file with correct extension
+    # For id3v1, id3v2.3, id3v2.4, use .mp3 extension since they're still MP3 files
+    actual_extension = "mp3" if format_type.lower() in ["id3v1", "id3v2.3", "id3v2.4"] else format_type.lower()
+    with tempfile.NamedTemporaryFile(suffix=f".{actual_extension}", delete=False) as tmp_file:
+        target_file = Path(tmp_file.name)
+
+    assets_dir = Path(__file__).parent.parent.parent / "test" / "assets"
+    AudioFileCreator.create_minimal_audio_file(target_file, format_type, assets_dir)
+
+    if format_type.lower() == "mp3":
+        ID3v2MetadataSetter.set_metadata(target_file, metadata)
+    elif format_type.lower() == "id3v1":
+        ID3v1MetadataSetter.set_metadata(target_file, metadata)
+    elif format_type.lower() in ["id3v2.3", "id3v2.4"]:
+        # Use version-specific ID3v2 metadata setting
+        version = format_type.lower().replace("id3v2.", "2.")
+        ID3v2MetadataSetter.set_metadata(target_file, metadata, version)
+    elif format_type.lower() == "flac":
+        VorbisMetadataSetter.set_metadata(target_file, metadata)
+    elif format_type.lower() == "wav":
+        RIFFMetadataSetter.set_metadata(target_file, metadata)
+    else:
+        msg = f"Unsupported format type: {format_type}"
+        raise ValueError(msg)
+
+    return target_file

audiometa/test/helpers/vorbis/__init__.py

@@ -0,0 +1,8 @@
+"""Vorbis metadata format helpers."""
+
+from .vorbis_header_verifier import VorbisHeaderVerifier
+from .vorbis_metadata_deleter import VorbisMetadataDeleter
+from .vorbis_metadata_getter import VorbisMetadataGetter
+from .vorbis_metadata_setter import VorbisMetadataSetter
+
+__all__ = ["VorbisMetadataGetter", "VorbisHeaderVerifier", "VorbisMetadataDeleter", "VorbisMetadataSetter"]

audiometa/test/helpers/vorbis/vorbis_header_verifier.py

@@ -0,0 +1,31 @@
+"""Vorbis metadata header verification and information utilities."""
+
+import subprocess
+from pathlib import Path
+
+from audiometa.utils.tool_path_resolver import get_tool_path
+
+from ..common.external_tool_runner import run_external_tool
+
+
+class VorbisHeaderVerifier:
+    """Utilities for verifying Vorbis metadata headers and retrieving metadata information from audio files."""
+
+    @staticmethod
+    def has_vorbis_comments(file_path: Path) -> bool:
+        """Check if file has Vorbis comments using metaflac."""
+        try:
+            result = subprocess.run(
+                [get_tool_path("metaflac"), "--list", str(file_path)], capture_output=True, text=True, check=True
+            )
+        except (subprocess.CalledProcessError, FileNotFoundError):
+            return False
+        else:
+            return "VORBIS_COMMENT" in result.stdout
+
+    @staticmethod
+    def get_metadata_info(file_path: Path) -> str:
+        """Get metadata info using metaflac --list command."""
+        command = [get_tool_path("metaflac"), "--list", str(file_path)]
+        result = run_external_tool(command, "metaflac")
+        return result.stdout

audiometa/test/helpers/vorbis/vorbis_metadata_deleter.py

@@ -0,0 +1,49 @@
+"""Vorbis metadata deletion operations."""
+
+import contextlib
+from pathlib import Path
+
+from ..common.external_tool_runner import run_external_tool
+
+
+class VorbisMetadataDeleter:
+    """Static utility class for Vorbis metadata deletion using external metaflac tool."""
+
+    @staticmethod
+    def delete_tag(file_path: Path, tag_name: str) -> None:
+        """Delete a specific Vorbis comment tag using metaflac tool."""
+        command = ["metaflac", "--remove-tag", tag_name, str(file_path)]
+        with contextlib.suppress(Exception):
+            run_external_tool(command, "metaflac")
+
+    @staticmethod
+    def delete_comment(file_path: Path) -> None:
+        VorbisMetadataDeleter.delete_tag(file_path, "COMMENT")
+
+    @staticmethod
+    def delete_title(file_path: Path) -> None:
+        VorbisMetadataDeleter.delete_tag(file_path, "TITLE")
+
+    @staticmethod
+    def delete_artist(file_path: Path) -> None:
+        VorbisMetadataDeleter.delete_tag(file_path, "ARTIST")
+
+    @staticmethod
+    def delete_album(file_path: Path) -> None:
+        VorbisMetadataDeleter.delete_tag(file_path, "ALBUM")
+
+    @staticmethod
+    def delete_genre(file_path: Path) -> None:
+        VorbisMetadataDeleter.delete_tag(file_path, "GENRE")
+
+    @staticmethod
+    def delete_lyrics(file_path: Path) -> None:
+        VorbisMetadataDeleter.delete_tag(file_path, "UNSYNCHRONIZED_LYRICS")
+
+    @staticmethod
+    def delete_language(file_path: Path) -> None:
+        VorbisMetadataDeleter.delete_tag(file_path, "LANGUAGE")
+
+    @staticmethod
+    def delete_bpm(file_path: Path) -> None:
+        VorbisMetadataDeleter.delete_tag(file_path, "BPM")