audiometa-python 0.2.2__py3-none-any.whl

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")

audiometa/test/helpers/vorbis/vorbis_metadata_getter.py

@@ -0,0 +1,67 @@
+"""Vorbis metadata inspection utilities for testing audio file metadata."""
+
+import subprocess
+from pathlib import Path
+
+from mutagen.flac import FLAC
+
+from audiometa.utils.tool_path_resolver import get_tool_path
+
+
+class VorbisMetadataGetter:
+    @staticmethod
+    def get_raw_metadata(file_path: Path) -> str:
+        result = subprocess.run(
+            [get_tool_path("metaflac"), "--list", str(file_path)], capture_output=True, text=True, check=True
+        )
+        return result.stdout
+
+    @staticmethod
+    def get_raw_metadata_without_truncating_null_bytes_but_lower_case_keys(file_path: Path) -> str:
+        audio = FLAC(str(file_path))
+        lines = []
+        lines.append("METADATA block #0")
+        lines.append("  type: 0 (STREAMINFO)")
+        lines.append("  is last: false")
+        lines.append("  length: 34")
+        lines.append("  minimum blocksize: 4096 samples")
+        lines.append("  maximum blocksize: 4096 samples")
+        lines.append("  minimum framesize: 0 bytes")
+        lines.append("  maximum framesize: 0 bytes")
+        lines.append("  sample_rate: 48000 Hz")
+        lines.append("  channels: 1")
+        lines.append("  bits-per-sample: 24")
+        lines.append("  total samples: 26177")
+        lines.append("  MD5 signature: 07598496b7623dfea10aafb241fae1a8")
+        lines.append("METADATA block #1")
+        lines.append("  type: 4 (VORBIS_COMMENT)")
+        lines.append("  is last: false")
+        lines.append("  length: 72")
+        lines.append("  vendor string: ")
+        comments = []
+        if audio.tags is not None and hasattr(audio.tags, "keys"):
+            for key in sorted(audio.tags.keys()):  # type: ignore[union-attr]
+                values = audio.tags[key]  # type: ignore[union-attr]
+                if isinstance(values, list):
+                    for value in values:
+                        comments.append(f"    comment[{len(comments)}]: {key}={value}")
+                else:
+                    comments.append(f"    comment[{len(comments)}]: {key}={values}")
+        lines.append(f"  comments: {len(comments)}")
+        lines.extend(comments)
+        lines.append("METADATA block #2")
+        lines.append("  type: 1 (PADDING)")
+        lines.append("  is last: true")
+        lines.append("  length: 1076")
+        return "\n".join(lines)
+
+    @staticmethod
+    def get_title(file_path: Path) -> str:
+        result = subprocess.run(
+            [get_tool_path("metaflac"), "--show-tag=TITLE", str(file_path)], capture_output=True, text=True, check=True
+        )
+        # Output is like "TITLE=Song Title\n"
+        lines = result.stdout.strip().split("\n")
+        if lines and "=" in lines[0]:
+            return lines[0].split("=", 1)[1]
+        return ""

audiometa/test/helpers/vorbis/vorbis_metadata_setter.py

@@ -0,0 +1,200 @@
+"""Vorbis metadata setting operations."""
+
+from pathlib import Path
+from typing import Any
+
+from mutagen.flac import FLAC
+
+from ..common.external_tool_runner import run_external_tool
+
+
+class VorbisMetadataSetter:
+    """Static utility class for Vorbis metadata setting using external tools."""
+
+    @staticmethod
+    def set_multiple_tags(
+        file_path: Path, tag_name: str, values: list[str], removing_existing=True, key_lower_case=False
+    ) -> None:
+        """Set multiple Vorbis comment tags with the same name."""
+
+        if key_lower_case:
+            tag_name = tag_name.lower()
+
+        if removing_existing:
+            try:
+                command = ["metaflac", "--remove-tag", tag_name, str(file_path)]
+                run_external_tool(command, "metaflac")
+            except Exception:
+                # Ignore if tags don't exist
+                pass
+
+        # Add each value as a separate tag
+        for value in values:
+            command = ["metaflac", "--set-tag", f"{tag_name}={value}", str(file_path)]
+            run_external_tool(command, "metaflac")
+
+    @staticmethod
+    def set_metadata(file_path: Path, metadata: dict[str, Any]) -> None:
+        """Set FLAC metadata using metaflac tool."""
+        cmd = ["metaflac"]
+
+        # Map common metadata keys to metaflac arguments
+        key_mapping = {
+            "title": "TITLE",
+            "artist": "ARTIST",
+            "album": "ALBUM",
+            "date": "DATE",
+            "genre": "GENRE",
+            "comment": "COMMENT",
+            "track_number": "TRACKNUMBER",
+            "bpm": "BPM",
+            "composer": "COMPOSER",
+            "copyright": "COPYRIGHT",
+            "lyrics": "LYRICS",
+            "language": "LANGUAGE",
+            "rating": "RATING",
+            "album_artist": "ALBUMARTIST",
+            "mood": "MOOD",
+            "key": "KEY",
+            "encoder": "ENCODER",
+            "url": "URL",
+            "isrc": "ISRC",
+            "publisher": "PUBLISHER",
+        }
+
+        metadata_added = False
+        for key, value in metadata.items():
+            if key.lower() in key_mapping:
+                cmd.extend([f"--set-tag={key_mapping[key.lower()]}={value}"])
+                metadata_added = True
+
+        # Only run metaflac if metadata was actually added
+        if metadata_added:
+            cmd.append(str(file_path))
+            run_external_tool(cmd, "metaflac")
+
+    @staticmethod
+    def set_genre(file_path: Path, genre_text: str) -> None:
+        command = ["metaflac", "--set-tag", f"GENRE={genre_text}", str(file_path)]
+        run_external_tool(command, "metaflac")
+
+    @staticmethod
+    def set_comment(file_path: Path, comment: str) -> None:
+        command = ["metaflac", "--set-tag", f"COMMENT={comment}", str(file_path)]
+        run_external_tool(command, "metaflac")
+
+    @staticmethod
+    def add_title(file_path: Path, title: str, key_lower_case=False) -> None:
+        if key_lower_case:
+            command = ["metaflac", "--set-tag", f"title={title}", str(file_path)]
+        else:
+            command = ["metaflac", "--set-tag", f"TITLE={title}", str(file_path)]
+        run_external_tool(command, "metaflac")
+
+    @staticmethod
+    def set_artist(file_path: Path, artist: str) -> None:
+        command = ["metaflac", "--set-tag", f"ARTIST={artist}", str(file_path)]
+        run_external_tool(command, "metaflac")
+
+    @staticmethod
+    def set_album(file_path: Path, album: str) -> None:
+        command = ["metaflac", "--set-tag", f"ALBUM={album}", str(file_path)]
+        run_external_tool(command, "metaflac")
+
+    @staticmethod
+    def set_lyrics(file_path: Path, lyrics: str) -> None:
+        command = ["metaflac", "--set-tag", f"LYRICS={lyrics}", str(file_path)]
+        run_external_tool(command, "metaflac")
+
+    @staticmethod
+    def set_language(file_path: Path, language: str) -> None:
+        command = ["metaflac", "--set-tag", f"LANGUAGE={language}", str(file_path)]
+        run_external_tool(command, "metaflac")
+
+    @staticmethod
+    def set_bpm(file_path: Path, bpm: int) -> None:
+        command = ["metaflac", "--set-tag", f"BPM={bpm}", str(file_path)]
+        run_external_tool(command, "metaflac")
+
+    @staticmethod
+    def set_release_date(file_path: Path, date_str: str) -> None:
+        """Set Vorbis release date using DATE tag."""
+        command = ["metaflac", "--set-tag", f"DATE={date_str}", str(file_path)]
+        run_external_tool(command, "metaflac")
+
+    @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-vorbis-max-metadata.sh", file_path, scripts_dir)
+
+    @staticmethod
+    def set_artists(
+        file_path: Path, artists: list[str], removing_existing=True, key_lower_case=False, in_single_entry=False
+    ) -> None:
+        """Set multiple Vorbis artists using mutagen."""
+        audio = FLAC(str(file_path))
+        key = "artist" if key_lower_case else "ARTIST"
+        if removing_existing:
+            existing = []
+        else:
+            existing = audio.get(key, [])
+            if isinstance(existing, str):
+                existing = [existing]
+        if in_single_entry:
+            value = "\x00".join(artists)
+            existing.append(value)
+        else:
+            existing.extend(artists)
+        audio[key] = existing
+        audio.save()
+
+    @staticmethod
+    def set_album_artists(file_path: Path, album_artists: list[str]):
+        """Set multiple Vorbis album artists using external metaflac tool."""
+        VorbisMetadataSetter.set_multiple_tags(file_path, "ALBUMARTIST", album_artists)
+
+    @staticmethod
+    def set_composers(file_path: Path, composers: list[str]):
+        """Set multiple Vorbis composers using external metaflac tool."""
+        VorbisMetadataSetter.set_multiple_tags(file_path, "COMPOSER", composers)
+
+    @staticmethod
+    def set_genres(file_path: Path, genres: list[str]):
+        """Set multiple Vorbis genres using external metaflac tool."""
+        VorbisMetadataSetter.set_multiple_tags(file_path, "GENRE", genres)
+
+    @staticmethod
+    def set_performers(file_path: Path, performers: list[str]):
+        """Set multiple Vorbis performers using external metaflac tool."""
+        VorbisMetadataSetter.set_multiple_tags(file_path, "PERFORMER", performers)
+
+    @staticmethod
+    def set_multiple_comments(file_path: Path, comments: list[str]):
+        """Set multiple Vorbis comments using external metaflac tool."""
+        VorbisMetadataSetter.set_multiple_tags(file_path, "COMMENT", comments)
+
+    @staticmethod
+    def set_null_bytes_test_metadata(file_path: Path) -> None:
+        """Set test metadata including null bytes for testing null byte handling."""
+        # First remove existing ARTIST tags
+        try:
+            command = ["metaflac", "--remove-tag=ARTIST", str(file_path)]
+            run_external_tool(command, "metaflac")
+        except Exception:
+            # Ignore if tags don't exist
+            pass
+
+        # Set ARTIST tags, one with null bytes
+        command = ["metaflac", "--set-tag=ARTIST=Artist\x00with\x00nulls", str(file_path)]
+        run_external_tool(command, "metaflac")
+
+        command = ["metaflac", "--set-tag=ARTIST=Normal Artist", str(file_path)]
+        run_external_tool(command, "metaflac")
+
+        # Set TITLE
+        command = ["metaflac", "--set-tag=TITLE=Normal Title", str(file_path)]
+        run_external_tool(command, "metaflac")