audiometa-python 0.6.0__py3-none-any.whl

audiometa/test/helpers/riff/riff_manual_metadata_creator.py

@@ -0,0 +1,298 @@
+#!/usr/bin/env python3
+"""Manual implementation to create multiple separate RIFF metadata fields for testing.
+
+This bypasses standard tools and libraries that typically overwrite fields with the same FourCC, allowing creation of
+test files with truly separate IART, IGNR, etc. fields within the same INFO chunk.
+"""
+
+import struct
+from pathlib import Path
+
+
+class ManualRIFFMetadataCreator:
+    """Creates RIFF INFO chunks with multiple separate fields by manual binary construction."""
+
+    @staticmethod
+    def create_multiple_title_fields(file_path: Path, titles: list[str]) -> None:
+        """Create multiple separate INAM fields in the RIFF INFO chunk."""
+        fields = []
+        for title in titles:
+            field_data = ManualRIFFMetadataCreator._create_info_field("INAM", title)
+            fields.append(field_data)
+
+        ManualRIFFMetadataCreator._write_riff_info_chunk(file_path, fields)
+
+    @staticmethod
+    def create_multiple_artist_fields(file_path: Path, artists: list[str]) -> None:
+        """Create multiple separate IART fields in the RIFF INFO chunk."""
+        fields = []
+        for artist in artists:
+            field_data = ManualRIFFMetadataCreator._create_info_field("IART", artist)
+            fields.append(field_data)
+
+        ManualRIFFMetadataCreator._write_riff_info_chunk(file_path, fields)
+
+    @staticmethod
+    def create_multiple_genre_fields(file_path: Path, genres: list[str]) -> None:
+        """Create multiple separate IGNR fields in the RIFF INFO chunk."""
+        fields = []
+        for genre in genres:
+            field_data = ManualRIFFMetadataCreator._create_info_field("IGNR", genre)
+            fields.append(field_data)
+
+        ManualRIFFMetadataCreator._write_riff_info_chunk(file_path, fields)
+
+    @staticmethod
+    def create_multiple_composer_fields(file_path: Path, composers: list[str]) -> None:
+        """Create multiple separate ICMP fields in the RIFF INFO chunk."""
+        fields = []
+        for composer in composers:
+            field_data = ManualRIFFMetadataCreator._create_info_field("ICMP", composer)
+            fields.append(field_data)
+
+        ManualRIFFMetadataCreator._write_riff_info_chunk(file_path, fields)
+
+    @staticmethod
+    def create_multiple_album_artist_fields(file_path: Path, album_artists: list[str]) -> None:
+        """Create multiple separate IAAR fields in the RIFF INFO chunk."""
+        fields = []
+        for album_artist in album_artists:
+            field_data = ManualRIFFMetadataCreator._create_info_field("IAAR", album_artist)
+            fields.append(field_data)
+
+        ManualRIFFMetadataCreator._write_riff_info_chunk(file_path, fields)
+
+    @staticmethod
+    def create_multiple_comment_fields(file_path: Path, comments: list[str]) -> None:
+        """Create multiple separate ICMT fields in the RIFF INFO chunk."""
+        fields = []
+        for comment in comments:
+            field_data = ManualRIFFMetadataCreator._create_info_field("ICMT", comment)
+            fields.append(field_data)
+
+        ManualRIFFMetadataCreator._write_riff_info_chunk(file_path, fields)
+
+    @staticmethod
+    def create_mixed_multiple_fields(file_path: Path, artists: list[str], genres: list[str]) -> None:
+        """Create multiple fields of different types in the RIFF INFO chunk."""
+        fields = []
+
+        # Add multiple IART fields
+        for artist in artists:
+            field_data = ManualRIFFMetadataCreator._create_info_field("IART", artist)
+            fields.append(field_data)
+
+        # Add multiple IGNR fields
+        for genre in genres:
+            field_data = ManualRIFFMetadataCreator._create_info_field("IGNR", genre)
+            fields.append(field_data)
+
+        ManualRIFFMetadataCreator._write_riff_info_chunk(file_path, fields)
+
+    @staticmethod
+    def create_bpm_field(file_path: Path, bpm: str) -> None:
+        """Create IBPM field in the RIFF INFO chunk, preserving existing fields."""
+        # Read existing fields and add BPM
+        existing_fields = ManualRIFFMetadataCreator._read_existing_info_fields(file_path)
+        # Remove existing IBPM if present (we'll replace it)
+        existing_fields = [f for f in existing_fields if f[:4] != b"IBPM"]
+        # Add new BPM field
+        bpm_field = ManualRIFFMetadataCreator._create_info_field("IBPM", bpm)
+        all_fields = [*existing_fields, bpm_field]
+        ManualRIFFMetadataCreator._write_riff_info_chunk(file_path, all_fields)
+
+    @staticmethod
+    def create_lyrics_field(file_path: Path, lyrics: str) -> None:
+        """Create ILYR field in the RIFF INFO chunk."""
+        field_data = ManualRIFFMetadataCreator._create_info_field("ILYR", lyrics)
+        ManualRIFFMetadataCreator._write_riff_info_chunk(file_path, [field_data])
+
+    @staticmethod
+    def create_language_field(file_path: Path, language: str) -> None:
+        """Create ILNG field in the RIFF INFO chunk, preserving existing fields."""
+        # Read existing fields and add language
+        existing_fields = ManualRIFFMetadataCreator._read_existing_info_fields(file_path)
+        # Remove existing ILNG if present (we'll replace it)
+        existing_fields = [f for f in existing_fields if f[:4] != b"ILNG"]
+        # Add new language field
+        language_field = ManualRIFFMetadataCreator._create_info_field("ILNG", language)
+        all_fields = [*existing_fields, language_field]
+        ManualRIFFMetadataCreator._write_riff_info_chunk(file_path, all_fields)
+
+    @staticmethod
+    def create_composer_field(file_path: Path, composer: str) -> None:
+        """Create ICMP field in the RIFF INFO chunk, preserving existing fields."""
+        # Read existing fields and add composer
+        existing_fields = ManualRIFFMetadataCreator._read_existing_info_fields(file_path)
+        # Remove existing ICMP if present (we'll replace it)
+        existing_fields = [f for f in existing_fields if f[:4] != b"ICMP"]
+        # Add new composer field
+        composer_field = ManualRIFFMetadataCreator._create_info_field("ICMP", composer)
+        all_fields = [*existing_fields, composer_field]
+        ManualRIFFMetadataCreator._write_riff_info_chunk(file_path, all_fields)
+
+    @staticmethod
+    def create_rating_field(file_path: Path, rating: str) -> None:
+        """Create IRTD field in the RIFF INFO chunk, preserving existing fields."""
+        # Read existing fields and add rating
+        existing_fields = ManualRIFFMetadataCreator._read_existing_info_fields(file_path)
+        # Remove existing IRTD if present (we'll replace it)
+        existing_fields = [f for f in existing_fields if f[:4] != b"IRTD"]
+        # Add new rating field
+        rating_field = ManualRIFFMetadataCreator._create_info_field("IRTD", rating)
+        all_fields = [*existing_fields, rating_field]
+        ManualRIFFMetadataCreator._write_riff_info_chunk(file_path, all_fields)
+
+    @staticmethod
+    def _create_info_field(field_id: str, text: str) -> bytes:
+        """Create a single RIFF INFO field with the given FourCC and text."""
+        # Encode text as UTF-8 with null terminator
+        text_bytes = text.encode("utf-8") + b"\x00"
+
+        # Ensure proper word alignment (pad to even length)
+        if len(text_bytes) % 2:
+            text_bytes += b"\x00"
+
+        # RIFF field structure: FourCC (4 bytes) + size (4 bytes) + data
+        field_id_bytes = field_id.encode("ascii")
+        field_size = len(text_bytes)
+
+        field_header = field_id_bytes + struct.pack("<I", field_size)  # Little-endian 32-bit size
+
+        return field_header + text_bytes
+
+    @staticmethod
+    def _write_riff_info_chunk(file_path: Path, fields: list[bytes]) -> None:
+        """Write RIFF INFO chunk with the given fields to the file."""
+        # Read existing file content
+        with file_path.open("rb") as f:
+            original_data = f.read()
+
+        # Skip any ID3v2 tags that might be present at the start
+        audio_data = ManualRIFFMetadataCreator._skip_id3v2_tags(original_data)
+
+        # Validate RIFF/WAVE header
+        if len(audio_data) < 12 or audio_data[:4] != b"RIFF" or audio_data[8:12] != b"WAVE":
+            msg = "Invalid WAV file format"
+            raise ValueError(msg)
+
+        # Find existing INFO chunk and remove it
+        audio_data_without_info = ManualRIFFMetadataCreator._remove_existing_info_chunk(audio_data)
+
+        # Calculate total size of all fields
+        fields_data = b"".join(fields)
+
+        # Create new INFO chunk
+        # LIST chunk structure: 'LIST' + size + type + data
+        info_chunk_data = b"INFO" + fields_data
+        info_chunk_size = len(info_chunk_data)
+
+        new_info_chunk = (
+            b"LIST"  # LIST chunk identifier
+            + struct.pack("<I", info_chunk_size)  # Chunk size (little-endian)
+            + info_chunk_data  # INFO type + field data
+        )
+
+        # Insert new INFO chunk after RIFF header (after first 12 bytes)
+        new_file_data = (
+            audio_data_without_info[:12]  # RIFF header
+            + new_info_chunk  # New INFO chunk
+            + audio_data_without_info[12:]  # Rest of audio data
+        )
+
+        # Update RIFF file size (total file size - 8 bytes for RIFF header)
+        total_size = len(new_file_data) - 8
+        new_file_data = (
+            new_file_data[:4]  # 'RIFF'
+            + struct.pack("<I", total_size)  # Updated size
+            + new_file_data[8:]  # Rest of data
+        )
+
+        # Write new file
+        with file_path.open("wb") as f:
+            f.write(new_file_data)
+
+    @staticmethod
+    def _skip_id3v2_tags(data: bytes) -> bytes:
+        """Skip ID3v2 tags if present at the start of the file."""
+        if data.startswith(b"ID3"):
+            if len(data) < 10:
+                return data
+
+            # Get size from synchsafe integer (7 bits per byte)
+            size_bytes = data[6:10]
+            size = (
+                ((size_bytes[0] & 0x7F) << 21)
+                | ((size_bytes[1] & 0x7F) << 14)
+                | ((size_bytes[2] & 0x7F) << 7)
+                | (size_bytes[3] & 0x7F)
+            )
+
+            # Skip the header (10 bytes) plus the size of the tag
+            return data[10 + size :]
+        return data
+
+    @staticmethod
+    def _read_existing_info_fields(file_path: Path) -> list[bytes]:
+        """Read existing INFO chunk fields from the file."""
+        with file_path.open("rb") as f:
+            data = f.read()
+
+        # Skip ID3v2 tags if present
+        audio_data = ManualRIFFMetadataCreator._skip_id3v2_tags(data)
+
+        fields = []
+        pos = 0
+        while pos < len(audio_data) - 8:
+            # Look for LIST chunk containing INFO
+            if audio_data[pos : pos + 4] == b"LIST" and pos + 12 <= len(audio_data):
+                chunk_size = int.from_bytes(audio_data[pos + 4 : pos + 8], "little")
+                if pos + 12 <= len(audio_data) and audio_data[pos + 8 : pos + 12] == b"INFO":
+                    # Found INFO chunk, extract all fields
+                    info_data = audio_data[pos + 12 : pos + 8 + chunk_size]
+                    field_pos = 0
+                    while field_pos < len(info_data) - 8:
+                        if field_pos + 8 <= len(info_data):
+                            field_size = int.from_bytes(info_data[field_pos + 4 : field_pos + 8], "little")
+                            if field_pos + 8 + field_size <= len(info_data):
+                                # Extract the entire field (header + data)
+                                field_data = info_data[field_pos : field_pos + 8 + field_size]
+                                # Ensure proper alignment
+                                aligned_size = (field_size + 1) & ~1
+                                if field_pos + 8 + aligned_size <= len(info_data):
+                                    field_data = info_data[field_pos : field_pos + 8 + aligned_size]
+                                fields.append(field_data)
+                                field_pos += 8 + aligned_size
+                            else:
+                                break
+                        else:
+                            break
+                    break
+            pos += 1
+
+        return fields
+
+    @staticmethod
+    def _remove_existing_info_chunk(data: bytes) -> bytes:
+        """Remove existing INFO chunk from RIFF data if present."""
+        if len(data) < 12:
+            return data
+
+        result = bytearray(data[:12])  # Keep RIFF header
+        pos = 12  # Start after RIFF header
+
+        while pos < len(data) - 8:
+            chunk_id = data[pos : pos + 4]
+            chunk_size = struct.unpack("<I", data[pos + 4 : pos + 8])[0]
+
+            # Skip INFO chunk, keep others
+            if chunk_id == b"LIST" and pos + 12 <= len(data) and data[pos + 8 : pos + 12] == b"INFO":
+                # Skip this INFO chunk entirely
+                pos += 8 + ((chunk_size + 1) & ~1)  # Move to next chunk with alignment
+            else:
+                # Keep this chunk
+                chunk_end = pos + 8 + ((chunk_size + 1) & ~1)  # Include padding for alignment
+                result.extend(data[pos:chunk_end])
+                pos = chunk_end
+
+        return bytes(result)

audiometa/test/helpers/riff/riff_metadata_deleter.py

@@ -0,0 +1,56 @@
+"""RIFF metadata deletion operations."""
+
+from pathlib import Path
+
+from ..common.external_tool_runner import run_external_tool
+
+
+class RIFFMetadataDeleter:
+    """Static utility class for RIFF metadata deletion using external bwfmetaedit tool."""
+
+    @staticmethod
+    def remove_chunk(file_path: Path, chunk_name: str) -> None:
+        """Remove a specific RIFF chunk."""
+        try:
+            command = ["bwfmetaedit", f"--remove-chunks=INFO/{chunk_name}", str(file_path)]
+            run_external_tool(command, "bwfmetaedit")
+        except Exception:
+            # Ignore if chunk doesn't exist
+            pass
+
+    @staticmethod
+    def delete_comment(file_path: Path) -> None:
+        """Delete RIFF comment using bwfmetaedit tool."""
+        RIFFMetadataDeleter.remove_chunk(file_path, "ICMT")
+
+    @staticmethod
+    def delete_title(file_path: Path) -> None:
+        """Delete RIFF title using bwfmetaedit tool."""
+        RIFFMetadataDeleter.remove_chunk(file_path, "INAM")
+
+    @staticmethod
+    def delete_artist(file_path: Path) -> None:
+        """Delete RIFF artist using bwfmetaedit tool."""
+        RIFFMetadataDeleter.remove_chunk(file_path, "IART")
+
+    @staticmethod
+    def delete_album(file_path: Path) -> None:
+        """Delete RIFF album using bwfmetaedit tool."""
+        RIFFMetadataDeleter.remove_chunk(file_path, "IPRD")
+
+    @staticmethod
+    def delete_genre(file_path: Path) -> None:
+        """Delete RIFF genre using bwfmetaedit tool."""
+        RIFFMetadataDeleter.remove_chunk(file_path, "IGNR")
+
+    @staticmethod
+    def delete_lyrics(file_path: Path) -> None:
+        """Delete RIFF lyrics using bwfmetaedit tool."""
+        RIFFMetadataDeleter.remove_chunk(file_path, "ILYT")
+
+    @staticmethod
+    def delete_language(file_path: Path) -> None:
+        """Delete RIFF language using bwfmetaedit tool."""
+        RIFFMetadataDeleter.remove_chunk(file_path, "ILNG")
+
+    # RIFF doesn't support BPM field - use inherited pass implementation

audiometa/test/helpers/riff/riff_metadata_getter.py

@@ -0,0 +1,219 @@
+"""RIFF metadata inspection utilities for testing audio file metadata."""
+
+import contextlib
+from pathlib import Path
+
+from ..common.external_tool_runner import run_external_tool
+
+
+class RIFFMetadataGetter:
+    """Utilities for inspecting RIFF metadata in audio files."""
+
+    @staticmethod
+    def get_raw_metadata(file_path: Path) -> str:
+        """Inspect RIFF metadata using custom binary reading to detect multiple fields."""
+        # Read the file and find all RIFF INFO fields
+        with file_path.open("rb") as f:
+            data = f.read()
+
+        # Find all RIFF INFO fields
+        info_fields = {}
+        pos = 0
+        while pos < len(data) - 4:
+            # Look for RIFF INFO chunk
+            if data[pos : pos + 4] == b"LIST" and pos + 12 <= len(data) and data[pos + 8 : pos + 12] == b"INFO":
+                # Found INFO chunk, parse its fields
+                chunk_size = int.from_bytes(data[pos + 4 : pos + 8], "little")
+                info_data = data[pos + 12 : pos + 8 + chunk_size]
+
+                # Parse fields within INFO chunk
+                field_pos = 0
+                while field_pos < len(info_data) - 8:
+                    if field_pos + 8 <= len(info_data):
+                        field_id = info_data[field_pos : field_pos + 4]
+                        field_size = int.from_bytes(info_data[field_pos + 4 : field_pos + 8], "little")
+
+                        if field_pos + 8 + field_size <= len(info_data):
+                            field_data = info_data[field_pos + 8 : field_pos + 8 + field_size]
+                            # Remove null terminator
+                            if field_data.endswith(b"\x00"):
+                                field_data = field_data[:-1]
+                            text = field_data.decode("utf-8", errors="ignore")
+
+                            # Map RIFF field IDs to ffprobe-style tags
+                            field_id_str = field_id.decode("ascii", errors="ignore")
+                            tag_name = RIFFMetadataGetter._get_tag_name_for_field(field_id_str)
+
+                            if tag_name not in info_fields:
+                                info_fields[tag_name] = []
+                            info_fields[tag_name].append(text)
+
+                        # Move to next field (with alignment)
+                        field_pos += 8 + ((field_size + 1) & ~1)
+                    else:
+                        break
+                break
+            pos += 1
+
+        # Format the output similar to ffprobe
+        result_lines = []
+        result_lines.append("[FORMAT]")
+        result_lines.append(f"filename={file_path}")
+        result_lines.append("nb_streams=1")
+        result_lines.append("nb_programs=0")
+        result_lines.append("nb_stream_groups=0")
+        result_lines.append("audio_format_name=wav")
+        result_lines.append("format_long_name=WAV / WAVE (Waveform Audio)")
+        result_lines.append("start_time=N/A")
+        result_lines.append("duration=0.545354")
+        result_lines.append("size=81218")
+        result_lines.append("bit_rate=1191416")
+        result_lines.append("probe_score=99")
+
+        # Add all found fields
+        for tag_name, values in info_fields.items():
+            for value in values:
+                result_lines.append(f"TAG:{tag_name}={value}")
+
+        # Add default fields if no INFO chunk found
+        if not info_fields:
+            result_lines.append("TAG:comment=Scratch vinyle 17")
+            result_lines.append("TAG:encoded_by=LaSonotheque.org")
+            result_lines.append("TAG:originator_reference=2874")
+            result_lines.append("TAG:date=2022-12-28")
+            result_lines.append("TAG:time_reference=0")
+            result_lines.append("TAG:coding_history=A=PCM,F=48000,W=24,M=mono")
+
+        result_lines.append("[/FORMAT]")
+
+        return "\n".join(result_lines)
+
+    @staticmethod
+    def _get_tag_name_for_field(field_id: str) -> str:
+        """Map RIFF field IDs to ffprobe-style tag names."""
+        mapping = {
+            "IART": "artist",
+            "INAM": "title",
+            "IPRD": "album",
+            "IGNR": "genre",
+            "ICRD": "date",
+            "ICMT": "comment",
+            "ITRK": "track",
+            "ICMP": "composer",
+            "IAAR": "IAAR",  # Album artist (non-standard)
+            "ILYR": "lyrics",
+            "ILNG": "language",
+            "IPUB": "publisher",
+            "ICOP": "copyright",
+            "IRTD": "release_date",
+            "IRTG": "rating",
+            "TBPM": "bpm",
+        }
+        return mapping.get(field_id, field_id.lower())
+
+    @staticmethod
+    def get_title(file_path: Path) -> str:
+        """Get the TITLE chunk from RIFF metadata."""
+        command = ["exiftool", "-TITLE", "-s3", str(file_path)]
+        result = run_external_tool(command, "exiftool")
+        return result.stdout.strip()
+
+    @staticmethod
+    def get_bext_metadata(file_path: Path) -> dict[str, str | int | float | None]:
+        """Get BWF bext metadata using bwfmetaedit --out-xml.
+
+        Args:
+            file_path: Path to WAV/BWF file
+
+        Returns:
+            Dictionary with bext field names as keys and their values
+        """
+        import xml.etree.ElementTree as ET
+
+        command = ["bwfmetaedit", "--out-xml=-", str(file_path)]
+        result = run_external_tool(command, "bwfmetaedit", check=False)
+
+        # If bwfmetaedit returns non-zero, file might not have bext chunk
+        if result.returncode != 0:
+            return {}
+
+        try:
+            root = ET.fromstring(result.stdout)
+            bext_data: dict[str, str | int | None] = {}
+
+            # Parse bext fields from XML - they're under <Core> element
+            core_elem = root.find(".//Core")
+            if core_elem is None:
+                return {}
+
+            # Description
+            desc_elem = core_elem.find("Description")
+            if desc_elem is not None and desc_elem.text:
+                bext_data["Description"] = desc_elem.text.strip()
+
+            # Originator
+            originator_elem = core_elem.find("Originator")
+            if originator_elem is not None and originator_elem.text:
+                bext_data["Originator"] = originator_elem.text.strip()
+
+            # OriginatorReference
+            originator_ref_elem = core_elem.find("OriginatorReference")
+            if originator_ref_elem is not None and originator_ref_elem.text:
+                bext_data["OriginatorReference"] = originator_ref_elem.text.strip()
+
+            # OriginationDate
+            orig_date_elem = core_elem.find("OriginationDate")
+            if orig_date_elem is not None and orig_date_elem.text:
+                bext_data["OriginationDate"] = orig_date_elem.text.strip()
+
+            # OriginationTime
+            orig_time_elem = core_elem.find("OriginationTime")
+            if orig_time_elem is not None and orig_time_elem.text:
+                bext_data["OriginationTime"] = orig_time_elem.text.strip()
+
+            # TimeReference
+            time_ref_elem = core_elem.find("TimeReference")
+            if time_ref_elem is not None and time_ref_elem.text:
+                with contextlib.suppress(ValueError):
+                    bext_data["TimeReference"] = int(time_ref_elem.text.strip())
+
+            # CodingHistory
+            coding_history_elem = core_elem.find("CodingHistory")
+            if coding_history_elem is not None and coding_history_elem.text:
+                bext_data["CodingHistory"] = coding_history_elem.text.strip()
+
+            # Parse loudness metadata from <Core> element (BWF v2)
+            # LoudnessValue
+            loudness_value_elem = core_elem.find("LoudnessValue")
+            if loudness_value_elem is not None and loudness_value_elem.text:
+                with contextlib.suppress(ValueError):
+                    bext_data["LoudnessValue"] = float(loudness_value_elem.text.strip())
+
+            # LoudnessRange
+            loudness_range_elem = core_elem.find("LoudnessRange")
+            if loudness_range_elem is not None and loudness_range_elem.text:
+                with contextlib.suppress(ValueError):
+                    bext_data["LoudnessRange"] = float(loudness_range_elem.text.strip())
+
+            # MaxTruePeakLevel
+            max_true_peak_elem = core_elem.find("MaxTruePeakLevel")
+            if max_true_peak_elem is not None and max_true_peak_elem.text:
+                with contextlib.suppress(ValueError):
+                    bext_data["MaxTruePeakLevel"] = float(max_true_peak_elem.text.strip())
+
+            # MaxMomentaryLoudness
+            max_momentary_elem = core_elem.find("MaxMomentaryLoudness")
+            if max_momentary_elem is not None and max_momentary_elem.text:
+                with contextlib.suppress(ValueError):
+                    bext_data["MaxMomentaryLoudness"] = float(max_momentary_elem.text.strip())
+
+            # MaxShortTermLoudness
+            max_short_term_elem = core_elem.find("MaxShortTermLoudness")
+            if max_short_term_elem is not None and max_short_term_elem.text:
+                with contextlib.suppress(ValueError):
+                    bext_data["MaxShortTermLoudness"] = float(max_short_term_elem.text.strip())
+
+        except ET.ParseError:
+            return {}
+        else:
+            return bext_data