audiometa-python 1.0.0__tar.gz → 1.1.2__tar.gz

{audiometa_python-1.0.0/audiometa_python.egg-info → audiometa_python-1.1.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: audiometa-python
-Version: 1.0.0
+Version: 1.1.2
 Summary: A comprehensive Python library for reading and writing audio metadata across multiple formats
 Author: AudioMeta Python Contributors
 Author-email: Andreas Garcia <garcia.andreas.1991@gmail.com>
@@ -46,7 +46,7 @@ Dynamic: license-file
 
 # AudioMeta Python
 
-[![CI](https://github.com/BehindTheMusicTree/audiometa/actions/workflows/ci.yml/badge.svg)](https://github.com/BehindTheMusicTree/audiometa/actions/workflows/ci.yml)
+[![Lint and Test](https://github.com/BehindTheMusicTree/audiometa/actions/workflows/lint-and-test.yml/badge.svg)](https://github.com/BehindTheMusicTree/audiometa/actions/workflows/lint-and-test.yml)
 [![Python](https://img.shields.io/badge/python-3.12%20%7C%203.13%20%7C%203.14-blue)](https://www.python.org/)
 [![License](https://img.shields.io/badge/license-Apache%202.0-green.svg)](LICENSE)
 [![PyPI version](https://img.shields.io/pypi/v/audiometa-python)](https://pypi.org/project/audiometa-python/)
@@ -413,7 +413,7 @@ except MetadataFieldNotSupportedByMetadataFormatError as e:
 
 #### Reading Full Metadata From All Formats Including Headers and Technical Info
 
-**`get_full_metadata(file_path, include_headers=True, include_technical=True, include_cover=True)`**
+**`get_full_metadata(file_path, include_headers=True, include_technical=True, include_raw_binary_data=False)`**
 
 Gets comprehensive metadata including all available information from a file, including headers and technical details even when no metadata is present.
 
@@ -688,7 +688,7 @@ id3v2_rating = get_unified_metadata_field("song.mp3", UnifiedMetadataKey.RATING,
 
 #### Reading Full Metadata From All Formats Including Headers and Technical Info
 
-**`get_full_metadata(file_path, include_headers=True, include_technical=True, include_cover=True)`**
+**`get_full_metadata(file_path, include_headers=True, include_technical=True, include_raw_binary_data=False)`**
 
 Gets comprehensive metadata including all available information from a file, including headers and technical details even when no metadata is present.
 
@@ -699,7 +699,7 @@ This function provides the most complete view of an audio file by combining:
 - All metadata from all supported formats (ID3v1, ID3v2, Vorbis, RIFF)
 - Technical information (duration, bitrate, sample rate, channels, file size)
 - Format-specific headers and structure information
-- Raw metadata details from each format
+- Raw metadata details from each format (when include_raw_binary_data is False, binary/opaque content such as APIC, PRIV, TRAKTOR4 is summarized as size placeholders)
 
 ```python
 from audiometa import get_full_metadata, UnifiedMetadataKey
@@ -738,7 +738,7 @@ print(f"Raw Vorbis Comments: {full_metadata['raw_metadata']['vorbis']['comments'
 - `file_path`: Path to the audio file (str or Path)
 - `include_headers`: Whether to include format-specific header information (default: True)
 - `include_technical`: Whether to include technical audio information (default: True)
-- `include_cover`: Whether to include cover/art image info in raw_metadata (default: True)
+- `include_raw_binary_data`: If True, include raw binary/opaque content in raw_metadata (e.g. PRIV, APIC, TRAKTOR4). If False (default), such content is replaced by size placeholders.
 
 **Returns:**
 A comprehensive dictionary containing:
@@ -866,9 +866,6 @@ metadata_only = get_full_metadata("song.mp3", include_technical=False)
 # Get only technical info without headers
 tech_only = get_full_metadata("song.mp3", include_headers=False)
 
-# Exclude cover/art from raw metadata
-no_cover = get_full_metadata("song.mp3", include_cover=False)
-
 # Check if file has specific format headers
 if full_info['headers']['id3v2']['present']:
     print("File has ID3v2 tags")
@@ -1514,6 +1511,9 @@ audiometa read song.mp3 --no-technical
 # Exclude header information
 audiometa read song.mp3 --no-headers
 
+# Include raw binary/opaque content in raw_metadata (default: size placeholders)
+audiometa read song.mp3 --include-raw-binary-data
+
 # Save to file
 audiometa read song.mp3 --output metadata.json
 ```

{audiometa_python-1.0.0 → audiometa_python-1.1.2}/README.md

@@ -4,7 +4,7 @@
 
 # AudioMeta Python
 
-[![CI](https://github.com/BehindTheMusicTree/audiometa/actions/workflows/ci.yml/badge.svg)](https://github.com/BehindTheMusicTree/audiometa/actions/workflows/ci.yml)
+[![Lint and Test](https://github.com/BehindTheMusicTree/audiometa/actions/workflows/lint-and-test.yml/badge.svg)](https://github.com/BehindTheMusicTree/audiometa/actions/workflows/lint-and-test.yml)
 [![Python](https://img.shields.io/badge/python-3.12%20%7C%203.13%20%7C%203.14-blue)](https://www.python.org/)
 [![License](https://img.shields.io/badge/license-Apache%202.0-green.svg)](LICENSE)
 [![PyPI version](https://img.shields.io/pypi/v/audiometa-python)](https://pypi.org/project/audiometa-python/)
@@ -371,7 +371,7 @@ except MetadataFieldNotSupportedByMetadataFormatError as e:
 
 #### Reading Full Metadata From All Formats Including Headers and Technical Info
 
-**`get_full_metadata(file_path, include_headers=True, include_technical=True, include_cover=True)`**
+**`get_full_metadata(file_path, include_headers=True, include_technical=True, include_raw_binary_data=False)`**
 
 Gets comprehensive metadata including all available information from a file, including headers and technical details even when no metadata is present.
 
@@ -646,7 +646,7 @@ id3v2_rating = get_unified_metadata_field("song.mp3", UnifiedMetadataKey.RATING,
 
 #### Reading Full Metadata From All Formats Including Headers and Technical Info
 
-**`get_full_metadata(file_path, include_headers=True, include_technical=True, include_cover=True)`**
+**`get_full_metadata(file_path, include_headers=True, include_technical=True, include_raw_binary_data=False)`**
 
 Gets comprehensive metadata including all available information from a file, including headers and technical details even when no metadata is present.
 
@@ -657,7 +657,7 @@ This function provides the most complete view of an audio file by combining:
 - All metadata from all supported formats (ID3v1, ID3v2, Vorbis, RIFF)
 - Technical information (duration, bitrate, sample rate, channels, file size)
 - Format-specific headers and structure information
-- Raw metadata details from each format
+- Raw metadata details from each format (when include_raw_binary_data is False, binary/opaque content such as APIC, PRIV, TRAKTOR4 is summarized as size placeholders)
 
 ```python
 from audiometa import get_full_metadata, UnifiedMetadataKey
@@ -696,7 +696,7 @@ print(f"Raw Vorbis Comments: {full_metadata['raw_metadata']['vorbis']['comments'
 - `file_path`: Path to the audio file (str or Path)
 - `include_headers`: Whether to include format-specific header information (default: True)
 - `include_technical`: Whether to include technical audio information (default: True)
-- `include_cover`: Whether to include cover/art image info in raw_metadata (default: True)
+- `include_raw_binary_data`: If True, include raw binary/opaque content in raw_metadata (e.g. PRIV, APIC, TRAKTOR4). If False (default), such content is replaced by size placeholders.
 
 **Returns:**
 A comprehensive dictionary containing:
@@ -824,9 +824,6 @@ metadata_only = get_full_metadata("song.mp3", include_technical=False)
 # Get only technical info without headers
 tech_only = get_full_metadata("song.mp3", include_headers=False)
 
-# Exclude cover/art from raw metadata
-no_cover = get_full_metadata("song.mp3", include_cover=False)
-
 # Check if file has specific format headers
 if full_info['headers']['id3v2']['present']:
     print("File has ID3v2 tags")
@@ -1472,6 +1469,9 @@ audiometa read song.mp3 --no-technical
 # Exclude header information
 audiometa read song.mp3 --no-headers
 
+# Include raw binary/opaque content in raw_metadata (default: size placeholders)
+audiometa read song.mp3 --include-raw-binary-data
+
 # Save to file
 audiometa read song.mp3 --output metadata.json
 ```

{audiometa_python-1.0.0 → audiometa_python-1.1.2}/audiometa/__init__.py

@@ -1264,7 +1264,7 @@ def get_full_metadata(
     file: PublicFileType,
     include_headers: bool = True,
     include_technical: bool = True,
-    include_cover: bool = True,
+    include_raw_binary_data: bool = False,
 ) -> dict[str, Any]:
     """Get comprehensive metadata including all available information from a file.
 
@@ -1274,13 +1274,20 @@ def get_full_metadata(
     - All metadata from all supported formats (ID3v1, ID3v2, Vorbis, RIFF)
     - Technical information (duration, bitrate, sample rate, channels, file size)
     - Format-specific headers and structure information
-    - Raw metadata details from each format
+    - Raw metadata details from each format. When include_raw_binary_data is False (default),
+      binary/opaque frames (e.g. APIC, PRIV, TRAKTOR4) are summarized as size placeholders.
+
+    The result's raw_metadata contains every tag present in the file for each format:
+    ID3v2 (all frames including custom TXXX/PRIV), Vorbis (all comments), ID3v1 (fixed set),
+    RIFF (all INFO chunk FourCCs including custom), and BWF bext in chunk_structure.
+    Per-format keys: id3v2.frames, vorbis.comments, id3v1/riff.parsed_fields, riff.chunk_structure.bext.
 
     Args:
         file: Audio file path (str or Path)
         include_headers: Whether to include format-specific header information (default: True)
         include_technical: Whether to include technical audio information (default: True)
-        include_cover: Whether to include cover/art image info in raw_metadata (default: True)
+        include_raw_binary_data: If True, include raw binary/opaque content in raw_metadata (e.g. PRIV, APIC,
+            TRAKTOR4). If False (default), such content is replaced by size placeholders.
 
     Returns:
         Comprehensive dictionary containing all available metadata and technical information
@@ -1395,10 +1402,12 @@ def get_full_metadata(
                         "extended_header": {},
                     }
 
-                # Get raw metadata information
+                # Get raw metadata information (optionally sanitize binary/opaque to placeholders)
                 try:
                     raw_info = manager.get_raw_metadata_info()
-                    raw_metadata_dict[format_key] = raw_info
+                    raw_metadata_dict[format_key] = (
+                        raw_info if include_raw_binary_data else manager.sanitize_raw_metadata_for_display(raw_info)
+                    )
                 except Exception:
                     raw_metadata_dict[format_key] = {
                         "raw_data": None,
@@ -1427,25 +1436,4 @@ def get_full_metadata(
                     "chunk_structure": {},
                 }
 
-    if not include_cover:
-        id3v2_raw = raw_metadata_dict.get("id3v2", {})
-        frames = id3v2_raw.get("frames", {})
-        if "APIC:" in frames:
-            raw_metadata_dict["id3v2"] = {
-                **id3v2_raw,
-                "frames": {k: v for k, v in frames.items() if k != "APIC:"},
-            }
-
-        riff_raw = raw_metadata_dict.get("riff", {})
-        riff_cover_parsed_keys = frozenset({"ICON"})
-        riff_cover_chunk_keys = frozenset({"cover", "image"})
-        parsed = riff_raw.get("parsed_fields", {})
-        chunk = riff_raw.get("chunk_structure", {})
-        if riff_cover_parsed_keys & frozenset(parsed) or riff_cover_chunk_keys & frozenset(chunk):
-            raw_metadata_dict["riff"] = {
-                **riff_raw,
-                "parsed_fields": {k: v for k, v in parsed.items() if k not in riff_cover_parsed_keys},
-                "chunk_structure": {k: v for k, v in chunk.items() if k not in riff_cover_chunk_keys},
-            }
-
     return result

{audiometa_python-1.0.0 → audiometa_python-1.1.2}/audiometa/cli.py

@@ -147,7 +147,7 @@ def _read_metadata(args: argparse.Namespace) -> None:
                     file_path,
                     include_headers=not getattr(args, "no_headers", False),
                     include_technical=not getattr(args, "no_technical", False),
-                    include_cover=not getattr(args, "no_cover", False),
+                    include_raw_binary_data=getattr(args, "include_raw_binary_data", False),
                 )
 
             output = format_output(metadata, args.output_format)
@@ -391,7 +391,12 @@ Examples:
     read_parser.add_argument("--output", "-o", help="Output file (default: stdout)")
     read_parser.add_argument("--no-headers", action="store_true", help="Exclude header information")
     read_parser.add_argument("--no-technical", action="store_true", help="Exclude technical information")
-    read_parser.add_argument("--no-cover", action="store_true", help="Exclude cover/art image from raw metadata")
+    read_parser.add_argument(
+        "--include-raw-binary-data",
+        action="store_true",
+        dest="include_raw_binary_data",
+        help="Include raw binary/opaque in raw_metadata (e.g. APIC, PRIV); default: size placeholders",
+    )
     read_parser.add_argument("--recursive", "-r", action="store_true", help="Process directories recursively")
     read_parser.add_argument(
         "--continue-on-error", action="store_true", help="Continue processing other files on error"

{audiometa_python-1.0.0 → audiometa_python-1.1.2}/audiometa/manager/_MetadataManager.py

@@ -816,6 +816,14 @@ class _MetadataManager:
         msg = "Not implemented for this format"
         raise NotImplementedError(msg)
 
+    def sanitize_raw_metadata_for_display(self, raw_info: dict) -> dict:
+        """Return raw_info with binary/opaque content replaced by size placeholders for safe display.
+
+        Override in managers whose raw metadata can contain binary or opaque data (e.g. ID3v2, Vorbis).
+        Default returns raw_info unchanged.
+        """
+        return raw_info
+
     def update_metadata(self, unified_metadata: UnifiedMetadata) -> None:
         if not self.metadata_keys_direct_map_write:
             msg = "This format does not support metadata modification"

{audiometa_python-1.0.0 → audiometa_python-1.1.2}/audiometa/manager/_rating_supporting/id3v2/_Id3v2Manager.py

@@ -30,6 +30,7 @@ from mutagen.id3._frames import (
 )
 from mutagen.id3._util import ID3NoHeaderError
 
+from audiometa.utils.raw_metadata_sanitizer import sanitize_id3v2_raw_info
 from audiometa.utils.unified_metadata_key import UnifiedMetadataKey
 
 if TYPE_CHECKING:
@@ -620,49 +621,13 @@ class _Id3v2Manager(_RatingSupportingMetadataManager):
 
             id3_metadata: ID3 = cast(ID3, self.raw_mutagen_metadata)
 
-            # Get raw frames (exclude binary frames like APIC)
             frames = {}
-            binary_frame_types = {
-                "APIC:",
-                "GEOB:",
-                "AENC:",
-                "RVA2:",
-                "RVRB:",
-                "EQU2:",
-                "PCNT:",
-                "POPM:",
-                "RBUF:",
-                "LINK:",
-                "POSS:",
-                "SYLT:",
-                "USLT:",
-                "SYTC:",
-                "ETCO:",
-                "MLLT:",
-                "OWNE:",
-                "COMR:",
-                "ENCR:",
-                "GRID:",
-                "PRIV:",
-                "SIGN:",
-                "SEEK:",
-                "ASPI:",
-            }
-
             for frame_id, frame in id3_metadata.items():
-                # Skip binary frames to avoid including large image/audio data
-                if frame_id in binary_frame_types:
-                    frames[frame_id] = {
-                        "text": f"<Binary data: {getattr(frame, 'size', 0)} bytes>",
-                        "size": getattr(frame, "size", 0),
-                        "flags": getattr(frame, "flags", 0),
-                    }
-                else:
-                    frames[frame_id] = {
-                        "text": str(frame) if hasattr(frame, "__str__") else repr(frame),
-                        "size": getattr(frame, "size", 0),
-                        "flags": getattr(frame, "flags", 0),
-                    }
+                frames[frame_id] = {
+                    "text": str(frame) if hasattr(frame, "__str__") else repr(frame),
+                    "size": getattr(frame, "size", 0),
+                    "flags": getattr(frame, "flags", 0),
+                }
         except Exception:
             return {"raw_data": None, "parsed_fields": {}, "frames": {}, "comments": {}, "chunk_structure": {}}
         else:
@@ -673,3 +638,6 @@ class _Id3v2Manager(_RatingSupportingMetadataManager):
                 "comments": {},
                 "chunk_structure": {},
             }
+
+    def sanitize_raw_metadata_for_display(self, raw_info: dict) -> dict:
+        return sanitize_id3v2_raw_info(raw_info)

{audiometa_python-1.0.0 → audiometa_python-1.1.2}/audiometa/manager/_rating_supporting/riff/_RiffManager.py

@@ -95,6 +95,10 @@ class _RiffManager(_RatingSupportingMetadataManager):
     Note: This manager is the preferred way to handle WAV metadata, as it uses the format's native metadata system
     rather than non-standard alternatives like ID3v2 tags. The custom implementation ensures proper handling of RIFF
     chunk structures, maintaining word alignment and size fields according to the specification.
+
+    Raw metadata: get_raw_metadata_info() (and thus get_full_metadata()["raw_metadata"]["riff"]) includes every
+    INFO chunk FourCC present in the file in parsed_fields (no filtering by RiffTagKey). Only subchunks with
+    a valid 4-byte printable-ASCII FourCC are included; custom and known FourCCs are both returned.
     """
 
     class RiffTagKey(RawMetadataKey):
@@ -193,7 +197,7 @@ class _RiffManager(_RatingSupportingMetadataManager):
 
         This method directly parses the RIFF structure to extract metadata from the INFO chunk.
         """
-        return extract_riff_metadata_directly(file_data, self._skip_id3v2_tags, self.RiffTagKey)
+        return extract_riff_metadata_directly(file_data, self._skip_id3v2_tags)
 
     def _extract_bext_chunk(self, file_data: bytes) -> dict[str, Any] | None:
         """Extract and parse the bext chunk from BWF files."""
@@ -253,10 +257,8 @@ class _RiffManager(_RatingSupportingMetadataManager):
         if hasattr(raw_mutagen_metadata_wav, "info") and raw_mutagen_metadata_wav.info is not None:
             info_tags = raw_mutagen_metadata_wav.info
             for key, value in info_tags.items():
-                # key is a FourCC string; check against enum member values
-                if any(key == member.value for member in self.RiffTagKey.__members__.values()):
-                    # info_tags now contains lists of values, so we can pass them directly
-                    raw_metadata_dict[key] = value
+                # info_tags contains lists of values; include every FourCC (known and custom)
+                raw_metadata_dict[key] = value
 
         return raw_metadata_dict
 

{audiometa_python-1.0.0 → audiometa_python-1.1.2}/audiometa/manager/_rating_supporting/riff/_riff_info_chunk.py

@@ -5,37 +5,34 @@ standard metadata fields like title, artist, album, etc.
 """
 
 from collections.abc import Callable
-from typing import TYPE_CHECKING, cast
 
 from ....utils.types import RawMetadataKey
+from ._riff_constants import RIFF_CHUNK_ID_SIZE, RIFF_HEADER_SIZE, RIFF_WAVE_FORMAT_POSITION
 
-if TYPE_CHECKING:
-    pass
+_FOURCC_MIN = 0x20
+_FOURCC_MAX = 0x7E
 
-from ._riff_constants import RIFF_CHUNK_ID_SIZE, RIFF_HEADER_SIZE, RIFF_WAVE_FORMAT_POSITION
+
+def _is_valid_fourcc(fourcc_bytes: bytes) -> bool:
+    """Return True if the 4 bytes form a valid INFO chunk FourCC (printable ASCII)."""
+    if len(fourcc_bytes) != RIFF_CHUNK_ID_SIZE:
+        return False
+    return all(_FOURCC_MIN <= b <= _FOURCC_MAX for b in fourcc_bytes)
 
 
 def extract_riff_metadata_directly(
-    file_data: bytes, skip_id3v2_tags_func: Callable[[bytes], bytes], riff_tag_key_class: type[object]
+    file_data: bytes, skip_id3v2_tags_func: Callable[[bytes], bytes]
 ) -> dict[str, list[str]]:
     """Manually extract metadata from RIFF chunks without relying on external libraries.
 
-    This function directly parses the RIFF structure to extract metadata from the INFO chunk.
-
-    Args:
-        file_data: Full file data (may include ID3v2 tags)
-        skip_id3v2_tags_func: Function to skip ID3v2 tags from file data
-        riff_tag_key_class: RiffTagKey class for validation
-
-    Returns:
-        Dictionary mapping RIFF tag IDs to lists of values
+    Parses the RIFF structure and returns every INFO chunk field. No filtering by
+    RiffTagKey—known and custom FourCCs are included. Only subchunks with a valid
+    4-byte printable-ASCII FourCC are accepted.
     """
     info_tags: dict[str, list[str]] = {}
 
-    # Skip ID3v2 if present
     file_data = skip_id3v2_tags_func(file_data)
 
-    # Validate RIFF header
     if (
         len(file_data) < RIFF_HEADER_SIZE
         or file_data[:RIFF_CHUNK_ID_SIZE] != b"RIFF"
@@ -43,40 +40,31 @@ def extract_riff_metadata_directly(
     ):
         return info_tags
 
-    pos = 12  # Start after RIFF header
+    pos = 12
     while pos < len(file_data) - 8:
         chunk_id = file_data[pos : pos + 4]
         chunk_size = int.from_bytes(file_data[pos + 4 : pos + 8], "little")
 
         if chunk_id == b"LIST" and pos + 12 <= len(file_data) and file_data[pos + 8 : pos + 12] == b"INFO":
-            # Process INFO chunk
             info_pos = pos + 12
             info_end = pos + 8 + chunk_size
 
             while info_pos < info_end - 8:
-                # Extract each metadata field
-                field_id = file_data[info_pos : info_pos + 4].decode("ascii", errors="ignore")
+                field_id_bytes = file_data[info_pos : info_pos + 4]
                 field_size = int.from_bytes(file_data[info_pos + 4 : info_pos + 8], "little")
 
-                if field_size > 0 and info_pos + 8 + field_size <= info_end:
-                    # -1 to exclude null terminator
+                if field_size > 0 and info_pos + 8 + field_size <= info_end and _is_valid_fourcc(field_id_bytes):
+                    field_id = field_id_bytes.decode("ascii")
                     field_data = file_data[info_pos + 8 : info_pos + 8 + field_size - 1]
                     try:
-                        # Decode and handle null-terminated strings
-                        field_value = field_data.decode("utf-8", errors="ignore")
-                        # Split on null byte and take first part if exists
-                        field_value = field_value.split("\x00")[0].strip()
-                        # Compare field_id with enum member values (FourCC strings)
-                        # Use getattr to safely access __members__ for type checking
-                        members = getattr(riff_tag_key_class, "__members__", {})
-                        if any(field_id == member.value for member in cast(dict, members).values()) and field_value:
+                        field_value = field_data.decode("utf-8", errors="ignore").split("\x00")[0].strip()
+                        if field_value:
                             if field_id not in info_tags:
                                 info_tags[field_id] = []
                             info_tags[field_id].append(field_value)
                     except UnicodeDecodeError:
                         pass
 
-                # Move to next field, maintaining alignment
                 info_pos += 8 + ((field_size + 1) & ~1)
             break
 

{audiometa_python-1.0.0 → audiometa_python-1.1.2}/audiometa/manager/_rating_supporting/vorbis/_VorbisManager.py

@@ -7,6 +7,7 @@ if TYPE_CHECKING:
     from ...._audio_file import _AudioFile
 from ....exceptions import FileCorruptedError, InvalidRatingValueError, MetadataFieldNotSupportedByMetadataFormatError
 from ....utils.rating_profiles import RatingWriteProfile
+from ....utils.raw_metadata_sanitizer import sanitize_vorbis_raw_info
 from ....utils.tool_path_resolver import get_tool_path
 from ....utils.types import RawMetadataDict, RawMetadataKey, UnifiedMetadata, UnifiedMetadataValue
 from ....utils.unified_metadata_key import UnifiedMetadataKey
@@ -480,19 +481,20 @@ class _VorbisManager(_RatingSupportingMetadataManager):
 
     def get_raw_metadata_info(self) -> dict:
         try:
-            # Use custom parsing to get metadata
             metadata = self._extract_mutagen_metadata()
-
             return {
-                "raw_data": None,  # Custom parsing handles this internally
+                "raw_data": None,
                 "parsed_fields": {},
                 "frames": {},
-                "comments": dict(metadata),  # Convert to regular dict
+                "comments": dict(metadata),
                 "chunk_structure": {},
             }
         except Exception:
             return {"raw_data": None, "parsed_fields": {}, "frames": {}, "comments": {}, "chunk_structure": {}}
 
+    def sanitize_raw_metadata_for_display(self, raw_info: dict) -> dict:
+        return sanitize_vorbis_raw_info(raw_info)
+
     def delete_metadata(self) -> bool:
         """Delete all metadata from the FLAC file by removing the VORBIS_COMMENT block."""
         import subprocess

{audiometa_python-1.0.0 → audiometa_python-1.1.2}/audiometa/test/helpers/id3v2/id3v2_metadata_setter.py

@@ -667,3 +667,14 @@ class ID3v2MetadataSetter:
 
         data_bytes = data.encode("utf-8")
         ManualID3v2FrameCreator.create_ufid_frame(file_path, owner, data_bytes, version="2.4")
+
+    @staticmethod
+    def set_custom_txxx(file_path: Path, description: str, value: str) -> None:
+        """Set a custom TXXX frame (for testing raw_metadata includes unsupported frames)."""
+        command = [
+            get_tool_path("mid3v2"),
+            "--TXXX",
+            f"{description}:{value}",
+            str(file_path),
+        ]
+        run_external_tool(command, "mid3v2")

{audiometa_python-1.0.0 → audiometa_python-1.1.2}/audiometa/test/helpers/riff/riff_manual_metadata_creator.py

@@ -342,3 +342,10 @@ class ManualRIFFMetadataCreator:
                 pos = chunk_end
 
         return bytes(result)
+
+    @staticmethod
+    def add_custom_info_field(file_path: Path, fourcc: str, value: str) -> None:
+        """Append a custom INFO chunk field (FourCC + value) for testing raw_metadata includes all tags."""
+        existing_fields = ManualRIFFMetadataCreator._read_existing_info_fields(file_path)
+        new_field = ManualRIFFMetadataCreator._create_info_field(fourcc, value)
+        ManualRIFFMetadataCreator._write_riff_info_chunk(file_path, [*existing_fields, new_field])

{audiometa_python-1.0.0 → audiometa_python-1.1.2}/audiometa/test/helpers/vorbis/vorbis_metadata_setter.py

@@ -33,6 +33,12 @@ class VorbisMetadataSetter:
             command = ["metaflac", "--set-tag", f"{tag_name}={value}", str(file_path)]
             run_external_tool(command, "metaflac")
 
+    @staticmethod
+    def set_tag(file_path: Path, tag_name: str, value: str) -> None:
+        """Set a single Vorbis comment tag (e.g. TRAKTOR4) using metaflac."""
+        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."""