audiometa-python 1.4.2__tar.gz → 1.4.3__tar.gz

{audiometa_python-1.4.2/audiometa_python.egg-info → audiometa_python-1.4.3}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: audiometa-python
-Version: 1.4.2
+Version: 1.4.3
 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>
@@ -27,7 +27,7 @@ Provides-Extra: dev
 Requires-Dist: pytest==9.0.1; extra == "dev"
 Requires-Dist: pytest-cov==4.0.0; extra == "dev"
 Requires-Dist: pytest-mock==3.15.1; extra == "dev"
-Requires-Dist: ruff==0.6.9; extra == "dev"
+Requires-Dist: ruff==0.15.9; extra == "dev"
 Requires-Dist: isort==5.13.2; extra == "dev"
 Requires-Dist: mypy==1.18.2; extra == "dev"
 Requires-Dist: pre-commit==3.0.0; extra == "dev"

{audiometa_python-1.4.2 → audiometa_python-1.4.3}/audiometa/__init__.py

@@ -38,35 +38,35 @@ from .utils.unified_metadata_field_schema import get_unified_metadata_field_sche
 from .utils.unified_metadata_key import UnifiedMetadataKey
 
 __all__ = [
-    "UnifiedMetadataKey",
-    "get_unified_metadata_field_schema",
-    "get_supported_unified_metadata_field_ids",
-    "FlacMd5State",
-    "MetadataFormat",
-    "MetadataWritingStrategy",
-    "UnifiedMetadata",
-    "UnifiedMetadataValue",
     "FileCorruptedError",
     "FileTypeNotSupportedError",
+    "FlacMd5State",
     "InvalidMetadataFieldTypeError",
     "MetadataFieldNotSupportedByLibError",
     "MetadataFieldNotSupportedByMetadataFormatError",
+    "MetadataFormat",
     "MetadataFormatNotSupportedByAudioFormatError",
     "MetadataWritingConflictParametersError",
-    "get_unified_metadata",
-    "get_unified_metadata_field",
-    "validate_metadata_for_update",
-    "update_metadata",
+    "MetadataWritingStrategy",
+    "UnifiedMetadata",
+    "UnifiedMetadataKey",
+    "UnifiedMetadataValue",
     "delete_all_metadata",
+    "fix_md5_checking",
     "get_bitrate",
     "get_channels",
+    "get_duration_in_sec",
     "get_file_size",
+    "get_full_metadata",
     "get_sample_rate",
+    "get_supported_unified_metadata_field_ids",
+    "get_unified_metadata",
+    "get_unified_metadata_field",
+    "get_unified_metadata_field_schema",
     "is_audio_file",
-    "get_duration_in_sec",
     "is_flac_md5_valid",
-    "fix_md5_checking",
-    "get_full_metadata",
+    "update_metadata",
+    "validate_metadata_for_update",
 ]
 
 FILE_EXTENSION_NOT_HANDLED_MESSAGE = "The file's format is not handled by the service."
@@ -124,7 +124,10 @@ def _get_metadata_manager(
     if not metadata_format:
         metadata_format = audio_file_prioritized_tag_formats[0]
     elif metadata_format not in audio_file_prioritized_tag_formats:
-        msg = f"Tag format {metadata_format} not supported for file extension {audio_file.file_extension}"
+        msg = (
+            f"Tag format {metadata_format.qualified_name()} not supported for file extension "
+            f"{audio_file.file_extension}"
+        )
         raise MetadataFormatNotSupportedByAudioFormatError(msg)
 
     manager_class: type[_MetadataManager] = cast(Any, METADATA_FORMAT_MANAGER_CLASS_MAP[metadata_format])
@@ -901,7 +904,9 @@ def _handle_metadata_strategy(
         except MetadataFieldNotSupportedByMetadataFormatError as e:
             # For SYNC strategy, log warning but continue with other formats
             if warn_on_unsupported_field:
-                format_warn_msg = f"Format {target_format_actual} doesn't support some metadata fields: {e}"
+                format_warn_msg = (
+                    f"Format {target_format_actual.qualified_name()} doesn't support some metadata fields: {e}"
+                )
                 warnings.warn(format_warn_msg, stacklevel=2)
         except Exception as e:
             # Re-raise user errors (like InvalidRatingValueError) immediately

{audiometa_python-1.4.2 → audiometa_python-1.4.3}/audiometa/_audio_file.py

@@ -7,7 +7,7 @@ import tempfile
 import types
 import warnings
 from pathlib import Path
-from typing import cast
+from typing import Self, cast
 
 from mutagen.flac import FLAC, StreamInfo
 from mutagen.mp3 import MP3
@@ -251,7 +251,7 @@ class _AudioFile:
         if hasattr(self.file, "close"):
             self.file.close()
 
-    def __enter__(self) -> "_AudioFile":
+    def __enter__(self) -> Self:
         return self
 
     def __exit__(
@@ -368,7 +368,7 @@ class _AudioFile:
             )
 
         # Create a temporary file to store the corrected FLAC content
-        temp_file = tempfile.NamedTemporaryFile(delete=False, suffix=".flac")
+        temp_file = tempfile.NamedTemporaryFile(delete=False, suffix=".flac")  # noqa: SIM115
         temp_path = temp_file.name
         temp_file.close()  # Close but don't delete yet
 

{audiometa_python-1.4.2 → audiometa_python-1.4.3}/audiometa/manager/_MetadataManager.py

@@ -251,8 +251,7 @@ class _MetadataManager:
 
         raise InvalidMetadataFieldFormatError(
             UnifiedMetadataKey.ISRC.value,
-            "12 alphanumeric characters (e.g., 'USRC17607839') or 15 characters with hyphens "
-            "(e.g., 'US-RC1-76-07839')",
+            "12 alphanumeric characters (e.g., 'USRC17607839') or 15 characters with hyphens (e.g., 'US-RC1-76-07839')",
             isrc,
         )
 
@@ -660,7 +659,7 @@ class _MetadataManager:
     def get_unified_metadata_field(self, unified_metadata_key: UnifiedMetadataKey) -> UnifiedMetadataValue:
         if unified_metadata_key not in self.metadata_keys_direct_map_read:
             metadata_format_name = self._get_formatted_metadata_format_name()
-            msg = f"{unified_metadata_key} metadata not supported by {metadata_format_name} format"
+            msg = f"{unified_metadata_key.qualified_name()} metadata not supported by {metadata_format_name} format"
             raise MetadataFieldNotSupportedByMetadataFormatError(msg)
 
         if self.raw_clean_metadata_uppercase_keys is None:
@@ -852,7 +851,10 @@ class _MetadataManager:
 
                 if unified_metadata_key not in self.metadata_keys_direct_map_write:
                     metadata_format_name = self._get_formatted_metadata_format_name()
-                    msg = f"{unified_metadata_key} metadata not supported by {metadata_format_name} format"
+                    msg = (
+                        f"{unified_metadata_key.qualified_name()} metadata not supported by "
+                        f"{metadata_format_name} format"
+                    )
                     raise MetadataFieldNotSupportedByMetadataFormatError(msg)
                 raw_metadata_key = self.metadata_keys_direct_map_write[unified_metadata_key]
                 if raw_metadata_key:

{audiometa_python-1.4.2 → audiometa_python-1.4.3}/audiometa/manager/_rating_supporting/_RatingSupportingMetadataManager.py

@@ -212,7 +212,9 @@ class _RatingSupportingMetadataManager(_MetadataManager):
             or UnifiedMetadataKey.RATING not in self.metadata_keys_direct_map_write
         ):
             metadata_format_name = self._get_formatted_metadata_format_name()
-            msg = f"{UnifiedMetadataKey.RATING} metadata not supported by {metadata_format_name} format"
+            msg = (
+                f"{UnifiedMetadataKey.RATING.qualified_name()} metadata not supported by {metadata_format_name} format"
+            )
             raise MetadataFieldNotSupportedByMetadataFormatError(msg)
 
         # Validate rating value before processing

{audiometa_python-1.4.2 → audiometa_python-1.4.3}/audiometa/manager/_rating_supporting/id3v2/_Id3v2Manager.py

@@ -426,7 +426,7 @@ class _Id3v2Manager(_RatingSupportingMetadataManager):
                 return None
             tpos_str = str(tpos_value[0])
             return parse_disc_total_from_combined_str(tpos_str)
-        msg = f"Metadata key not handled: {unified_metadata_key}"
+        msg = f"Metadata key not handled: {unified_metadata_key.qualified_name()}"
         raise MetadataFieldNotSupportedByMetadataFormatError(msg)
 
     def _update_formatted_value_in_raw_mutagen_metadata(
@@ -510,7 +510,7 @@ class _Id3v2Manager(_RatingSupportingMetadataManager):
             app_metadata_value = unified_metadata[unified_metadata_key]
             if unified_metadata_key not in self.metadata_keys_direct_map_write:
                 metadata_format_name = self._get_formatted_metadata_format_name()
-                msg = f"{unified_metadata_key} metadata not supported by {metadata_format_name} format"
+                msg = f"{unified_metadata_key.qualified_name()} metadata not supported by {metadata_format_name} format"
                 raise MetadataFieldNotSupportedByMetadataFormatError(msg)
             raw_metadata_key = self.metadata_keys_direct_map_write[unified_metadata_key]
             if raw_metadata_key:

{audiometa_python-1.4.2 → audiometa_python-1.4.3}/audiometa/manager/_rating_supporting/id3v2/_id3v2_reader.py

@@ -254,5 +254,5 @@ class _Id3v2Reader:
         """
         uuid_hex_length = 32
         if len(uuid_str) == uuid_hex_length and all(c in "0123456789abcdefABCDEF" for c in uuid_str):
-            return f"{uuid_str[:8]}-{uuid_str[8:12]}-" f"{uuid_str[12:16]}-{uuid_str[16:20]}-{uuid_str[20:32]}"
+            return f"{uuid_str[:8]}-{uuid_str[8:12]}-{uuid_str[12:16]}-{uuid_str[16:20]}-{uuid_str[20:32]}"
         return uuid_str

{audiometa_python-1.4.2 → audiometa_python-1.4.3}/audiometa/manager/_rating_supporting/id3v2/_id3v2_writer.py

@@ -6,6 +6,7 @@ from mutagen.id3 import ID3
 from mutagen.id3._frames import TPOS, TXXX, UFID
 
 from audiometa.manager._MetadataManager import _MetadataManager as MetadataManager
+from audiometa.utils.disc_number_read import parse_disc_number_from_combined_str, parse_disc_total_from_combined_str
 from audiometa.utils.types import RawMetadataKey, UnifiedMetadataValue
 from audiometa.utils.unified_metadata_key import UnifiedMetadataKey
 
@@ -285,11 +286,7 @@ class _Id3v2Writer:
             current_total = None
             if current_tpos and len(current_tpos.text) > 0:
                 tpos_str = str(current_tpos.text[0])
-                import re
-
-                match = re.match(r"^(\d+)/(\d+)$", tpos_str)
-                if match:
-                    current_total = int(match.group(2))
+                current_total = parse_disc_total_from_combined_str(tpos_str)
 
             raw_mutagen_metadata.delall(tpos_key)
             if app_metadata_value is not None:
@@ -304,11 +301,7 @@ class _Id3v2Writer:
             current_disc_number = None
             if current_tpos and len(current_tpos.text) > 0:
                 tpos_str = str(current_tpos.text[0])
-                import re
-
-                match = re.match(r"^(\d+)(?:/(\d+))?$", tpos_str)
-                if match:
-                    current_disc_number = int(match.group(1))
+                current_disc_number = parse_disc_number_from_combined_str(tpos_str)
 
             raw_mutagen_metadata.delall(tpos_key)
             if app_metadata_value is not None:

{audiometa_python-1.4.2 → audiometa_python-1.4.3}/audiometa/manager/_rating_supporting/riff/_RiffManager.py

@@ -307,7 +307,7 @@ class _RiffManager(_RatingSupportingMetadataManager):
             except Exception:
                 pass
             return None
-        msg = f"Metadata key not handled: {unified_metadata_key}"
+        msg = f"Metadata key not handled: {unified_metadata_key.qualified_name()}"
         raise MetadataFieldNotSupportedByMetadataFormatError(msg)
 
     def _update_not_using_mutagen_metadata(self, unified_metadata: UnifiedMetadata) -> None:
@@ -344,7 +344,7 @@ class _RiffManager(_RatingSupportingMetadataManager):
 
         for unified_metadata_key in unified_metadata:
             if unified_metadata_key not in self.metadata_keys_direct_map_write:
-                msg = f"{unified_metadata_key} metadata not supported by RIFF format"
+                msg = f"{unified_metadata_key.qualified_name()} metadata not supported by RIFF format"
                 raise MetadataFieldNotSupportedByMetadataFormatError(msg)
 
     def _read_file_data_for_update(self) -> tuple[bytearray, bool]:

{audiometa_python-1.4.2 → audiometa_python-1.4.3}/audiometa/manager/_rating_supporting/vorbis/_VorbisManager.py

@@ -388,6 +388,32 @@ class _VorbisManager(_RatingSupportingMetadataManager):
         # Get current metadata
         current_metadata = self._extract_mutagen_metadata()
 
+        # Preserve total when existing DISCNUMBER is stored as combined n/m or n-m and only DISC_NUMBER is updated.
+        if (
+            UnifiedMetadataKey.DISC_NUMBER in unified_metadata
+            and UnifiedMetadataKey.DISC_TOTAL not in unified_metadata
+            and unified_metadata[UnifiedMetadataKey.DISC_NUMBER] is not None
+        ):
+            explicit_total = None
+            combined_discnumber = None
+            for raw_key, raw_values in current_metadata.items():
+                key_name = str(raw_key).upper()
+                if raw_values is None or len(raw_values) == 0 or raw_values[0] in (None, ""):
+                    continue
+                if key_name == self.VorbisKey.DISC_TOTAL.value:
+                    explicit_total = str(raw_values[0])
+                elif key_name == self.VorbisKey.DISC_NUMBER.value:
+                    combined_discnumber = str(raw_values[0])
+
+            explicit_total_is_usable = (
+                explicit_total is not None and parse_explicit_non_negative_disctotal(explicit_total) is not None
+            )
+
+            if not explicit_total_is_usable and combined_discnumber is not None:
+                parsed_total = parse_disc_total_from_combined_str(combined_discnumber)
+                if parsed_total is not None:
+                    unified_metadata[UnifiedMetadataKey.DISC_TOTAL] = parsed_total
+
         # Update metadata dict
         for unified_metadata_key in list(unified_metadata.keys()):
             app_metadata_value = unified_metadata[unified_metadata_key]
@@ -401,7 +427,7 @@ class _VorbisManager(_RatingSupportingMetadataManager):
 
             if unified_metadata_key not in self.metadata_keys_direct_map_write:
                 metadata_format_name = self._get_formatted_metadata_format_name()
-                msg = f"{unified_metadata_key} metadata not supported by {metadata_format_name} format"
+                msg = f"{unified_metadata_key.qualified_name()} metadata not supported by {metadata_format_name} format"
                 raise MetadataFieldNotSupportedByMetadataFormatError(msg)
             raw_metadata_key = self.metadata_keys_direct_map_write[unified_metadata_key]
             if raw_metadata_key:
@@ -563,7 +589,7 @@ class _VorbisManager(_RatingSupportingMetadataManager):
     def _get_undirectly_mapped_metadata_value_other_than_rating_from_raw_clean_metadata(
         self, _raw_clean_metadata: RawMetadataDict, unified_metadata_key: UnifiedMetadataKey
     ) -> UnifiedMetadataValue:
-        msg = f"Metadata key not handled: {unified_metadata_key}"
+        msg = f"Metadata key not handled: {unified_metadata_key.qualified_name()}"
         raise MetadataFieldNotSupportedByMetadataFormatError(msg)
 
     def _update_undirectly_mapped_metadata(
@@ -600,5 +626,5 @@ class _VorbisManager(_RatingSupportingMetadataManager):
                 if self.VorbisKey.RATING_TRAKTOR in raw_mutagen_metadata:
                     del raw_mutagen_metadata[self.VorbisKey.RATING_TRAKTOR]
         else:
-            msg = f"Metadata key not handled: {unified_metadata_key}"
+            msg = f"Metadata key not handled: {unified_metadata_key.qualified_name()}"
             raise MetadataFieldNotSupportedByMetadataFormatError(msg)

{audiometa_python-1.4.2 → audiometa_python-1.4.3}/audiometa/manager/id3v1/_Id3v1Manager.py

@@ -161,7 +161,7 @@ class _Id3v1Manager(_MetadataManager):
                 raw_clean_metadata=raw_clean_metadata_uppercase_keys,
                 raw_metadata_ket=Id3v1RawMetadataKey.GENRE_CODE_OR_NAME,
             )
-        msg = f"{unified_metadata_key} metadata is not undirectly handled"
+        msg = f"{unified_metadata_key.qualified_name()} metadata is not undirectly handled"
         raise MetadataFieldNotSupportedByMetadataFormatError(msg)
 
     def _update_undirectly_mapped_metadata(
@@ -187,7 +187,7 @@ class _Id3v1Manager(_MetadataManager):
                 if genre_code is not None:
                     tags[Id3v1RawMetadataKey.GENRE_CODE_OR_NAME] = [str(genre_code)]
         else:
-            msg = f"{unified_metadata_key} metadata is not undirectly handled"
+            msg = f"{unified_metadata_key.qualified_name()} metadata is not undirectly handled"
             raise MetadataFieldNotSupportedByMetadataFormatError(msg)
 
     def _update_formatted_value_in_raw_mutagen_metadata(
@@ -204,8 +204,7 @@ class _Id3v1Manager(_MetadataManager):
 
         # If value is None, remove the field (delete from tags)
         if app_metadata_value is None:
-            if raw_metadata_key in tags:
-                del tags[raw_metadata_key]
+            tags.pop(raw_metadata_key, None)
             return
 
         # Convert and truncate the value according to ID3v1 constraints
@@ -258,7 +257,7 @@ class _Id3v1Manager(_MetadataManager):
         for unified_metadata_key in unified_metadata:
             if unified_metadata_key not in self.metadata_keys_direct_map_write:
                 metadata_format_name = self._get_formatted_metadata_format_name()
-                msg = f"{unified_metadata_key} metadata not supported by {metadata_format_name} format"
+                msg = f"{unified_metadata_key.qualified_name()} metadata not supported by {metadata_format_name} format"
                 raise MetadataFieldNotSupportedByMetadataFormatError(msg)
 
         # Read the entire file

{audiometa_python-1.4.2 → audiometa_python-1.4.3}/audiometa/test/helpers/id3v1/__init__.py

@@ -5,4 +5,4 @@ from .id3v1_metadata_deleter import ID3v1MetadataDeleter
 from .id3v1_metadata_getter import ID3v1MetadataGetter
 from .id3v1_metadata_setter import ID3v1MetadataSetter
 
-__all__ = ["ID3v1MetadataDeleter", "ID3v1MetadataSetter", "ID3v1HeaderVerifier", "ID3v1MetadataGetter"]
+__all__ = ["ID3v1HeaderVerifier", "ID3v1MetadataDeleter", "ID3v1MetadataGetter", "ID3v1MetadataSetter"]

{audiometa_python-1.4.2 → audiometa_python-1.4.3}/audiometa/test/helpers/id3v2/__init__.py

@@ -15,14 +15,10 @@ from .id3v2_metadata_setter import ID3v2MetadataSetter
 
 
 __all__ = [
-    # Core operations
+    "ExternalMetadataToolError",
     "ID3v2HeaderVerifier",
     "ID3v2MetadataDeleter",
-    "ID3v2MetadataSetter",
     "ID3v2MetadataGetter",
-    # Specialized managers (moved to ID3v2MetadataSetter)
-    # Advanced tools
+    "ID3v2MetadataSetter",
     "ManualID3v2FrameCreator",
-    # External tool wrappers
-    "ExternalMetadataToolError",
 ]

{audiometa_python-1.4.2 → audiometa_python-1.4.3}/audiometa/test/helpers/riff/__init__.py

@@ -5,4 +5,4 @@ from .riff_metadata_deleter import RIFFMetadataDeleter
 from .riff_metadata_getter import RIFFMetadataGetter
 from .riff_metadata_setter import RIFFMetadataSetter
 
-__all__ = ["RIFFMetadataGetter", "RIFFHeaderVerifier", "RIFFMetadataDeleter", "RIFFMetadataSetter"]
+__all__ = ["RIFFHeaderVerifier", "RIFFMetadataDeleter", "RIFFMetadataGetter", "RIFFMetadataSetter"]

{audiometa_python-1.4.2 → audiometa_python-1.4.3}/audiometa/test/helpers/vorbis/__init__.py

@@ -5,4 +5,4 @@ from .vorbis_metadata_deleter import VorbisMetadataDeleter
 from .vorbis_metadata_getter import VorbisMetadataGetter
 from .vorbis_metadata_setter import VorbisMetadataSetter
 
-__all__ = ["VorbisMetadataGetter", "VorbisHeaderVerifier", "VorbisMetadataDeleter", "VorbisMetadataSetter"]
+__all__ = ["VorbisHeaderVerifier", "VorbisMetadataDeleter", "VorbisMetadataGetter", "VorbisMetadataSetter"]

{audiometa_python-1.4.2 → audiometa_python-1.4.3}/audiometa/test/tests/e2e/cli/error_handling/test_multiple_files_errors.py

@@ -115,9 +115,9 @@ class TestCLIMultipleFilesErrors:
 
             # Should contain success messages for valid files
             stdout_output = result.stdout.lower()
-            assert (
-                "updated metadata for" in stdout_output
-            ), f"Expected success message in stdout but got:\nSTDOUT: {result.stdout}\nSTDERR: {result.stderr}"
+            assert "updated metadata for" in stdout_output, (
+                f"Expected success message in stdout but got:\nSTDOUT: {result.stdout}\nSTDERR: {result.stderr}"
+            )
 
             # Should contain error message for unsupported file
             stderr_output = result.stderr.lower()
@@ -151,9 +151,9 @@ class TestCLIMultipleFilesErrors:
 
             # Should contain messages for processed files
             stdout_output = result.stdout.lower()
-            assert (
-                "deleted" in stdout_output or "found" in stdout_output
-            ), f"Expected success message in stdout but got:\nSTDOUT: {result.stdout}\nSTDERR: {result.stderr}"
+            assert "deleted" in stdout_output or "found" in stdout_output, (
+                f"Expected success message in stdout but got:\nSTDOUT: {result.stdout}\nSTDERR: {result.stderr}"
+            )
 
             # Should contain error message for unsupported file
             stderr_output = result.stderr.lower()

{audiometa_python-1.4.2 → audiometa_python-1.4.3}/audiometa/test/tests/integration/get_full_metadata/test_binary_data_filtering.py

@@ -51,14 +51,14 @@ class TestGetFullMetadataBinaryDataFiltering:
         for frame_id, frame_data in id3v2_frames.items():
             text = frame_data.get("text", "")
 
-            assert not any(
-                ord(c) < 32 and c not in "\t\n\r" for c in text
-            ), f"Frame {frame_id} contains binary data in text: {text[:50]!r}"
+            assert not any(ord(c) < 32 and c not in "\t\n\r" for c in text), (
+                f"Frame {frame_id} contains binary data in text: {text[:50]!r}"
+            )
 
             if _is_binary_frame(frame_id):
-                assert text.startswith(
-                    "<Binary data:"
-                ), f"Binary frame {frame_id} should have placeholder text, got: {text}"
+                assert text.startswith("<Binary data:"), (
+                    f"Binary frame {frame_id} should have placeholder text, got: {text}"
+                )
                 assert text.endswith(" bytes>"), f"Binary frame {frame_id} should end with ' bytes>', got: {text}"
 
     def test_get_full_metadata_id3v2_binary_frames_sanitized(self, sample_mp3_file):
@@ -72,9 +72,9 @@ class TestGetFullMetadataBinaryDataFiltering:
                 assert text.startswith("<Binary data:"), f"Binary frame {frame_id} should have placeholder text"
                 assert text.endswith(" bytes>"), f"Binary frame {frame_id} should end with ' bytes>'"
             else:
-                assert not any(
-                    ord(c) < 32 and c not in "\t\n\r" for c in text
-                ), f"Text frame {frame_id} contains binary data: {text[:50]!r}"
+                assert not any(ord(c) < 32 and c not in "\t\n\r" for c in text), (
+                    f"Text frame {frame_id} contains binary data: {text[:50]!r}"
+                )
 
     def test_get_full_metadata_vorbis_no_binary_data(self, sample_flac_file):
         """Test that get_full_metadata Vorbis comments don't contain binary data."""
@@ -86,9 +86,9 @@ class TestGetFullMetadataBinaryDataFiltering:
             assert isinstance(values, list), f"Vorbis comment {key} should be a list"
             for value in values:
                 assert isinstance(value, str), f"Vorbis comment {key} value should be string"
-                assert not any(
-                    ord(c) < 32 and c not in "\t\n\r" for c in value
-                ), f"Vorbis comment {key} contains binary data: {value[:50]!r}"
+                assert not any(ord(c) < 32 and c not in "\t\n\r" for c in value), (
+                    f"Vorbis comment {key} contains binary data: {value[:50]!r}"
+                )
 
     def test_get_full_metadata_vorbis_opaque_comment_sanitized(self):
         """TRAKTOR4 and other opaque Vorbis comment keys are replaced with size placeholder."""
@@ -133,9 +133,9 @@ class TestGetFullMetadataBinaryDataFiltering:
         for key, value in riff_fields.items():
             assert isinstance(value, str), f"RIFF field {key} should be string"
             # Check for binary data patterns
-            assert not any(
-                ord(c) < 32 and c not in "\t\n\r" for c in value
-            ), f"RIFF field {key} contains binary data: {value[:50]!r}"
+            assert not any(ord(c) < 32 and c not in "\t\n\r" for c in value), (
+                f"RIFF field {key} contains binary data: {value[:50]!r}"
+            )
 
     def test_get_full_metadata_id3v1_no_binary_data(self, sample_mp3_file):
         """Test that get_full_metadata ID3v1 metadata doesn't contain binary data."""
@@ -147,9 +147,9 @@ class TestGetFullMetadataBinaryDataFiltering:
         for key, value in id3v1_fields.items():
             assert isinstance(value, str), f"ID3v1 field {key} should be string"
             # Check for binary data patterns
-            assert not any(
-                ord(c) < 32 and c not in "\t\n\r" for c in value
-            ), f"ID3v1 field {key} contains binary data: {value[:50]!r}"
+            assert not any(ord(c) < 32 and c not in "\t\n\r" for c in value), (
+                f"ID3v1 field {key} contains binary data: {value[:50]!r}"
+            )
 
     def test_cli_output_no_binary_data(self, sample_mp3_file):
         """Test that CLI output doesn't contain binary data."""

{audiometa_python-1.4.2 → audiometa_python-1.4.3}/audiometa/test/tests/integration/get_full_metadata/test_structure.py

@@ -92,9 +92,9 @@ class TestGetFullMetadataStructure:
 
         # If there are parsed fields, they should use UnifiedMetadataKey enum values as keys
         for key in parsed_fields:
-            assert isinstance(
-                key, UnifiedMetadataKey
-            ), f"ID3v1 parsed_fields key {key} should be UnifiedMetadataKey enum, got {type(key)}"
+            assert isinstance(key, UnifiedMetadataKey), (
+                f"ID3v1 parsed_fields key {key} should be UnifiedMetadataKey enum, got {type(key)}"
+            )
             # Verify it's a valid UnifiedMetadataKey value
             assert key in UnifiedMetadataKey, f"ID3v1 parsed_fields key {key} is not a valid UnifiedMetadataKey"
 
@@ -138,9 +138,9 @@ class TestGetFullMetadataStructure:
             assert isinstance(key, str), f"ID3v1 parsed_fields key in CLI output should be string, got: {type(key)}"
 
             # Verify it's a valid UnifiedMetadataKey value
-            assert key in [
-                e.value for e in UnifiedMetadataKey
-            ], f"ID3v1 parsed_fields key {key} is not a valid UnifiedMetadataKey value"
+            assert key in [e.value for e in UnifiedMetadataKey], (
+                f"ID3v1 parsed_fields key {key} is not a valid UnifiedMetadataKey value"
+            )
 
     def test_parsed_fields_consistency_across_formats(self, sample_mp3_file: Path):
         result = get_full_metadata(sample_mp3_file)
@@ -150,12 +150,12 @@ class TestGetFullMetadataStructure:
         # Check that all formats have the expected structure
         for metadata_format_name, format_data in raw_metadata.items():
             assert "parsed_fields" in format_data, f"Format {metadata_format_name} should have parsed_fields"
-            assert isinstance(
-                format_data["parsed_fields"], dict
-            ), f"Format {metadata_format_name} parsed_fields should be a dictionary"
+            assert isinstance(format_data["parsed_fields"], dict), (
+                f"Format {metadata_format_name} parsed_fields should be a dictionary"
+            )
 
             # Check that parsed_fields values are strings (no binary data)
             for key, value in format_data["parsed_fields"].items():
-                assert isinstance(
-                    value, str
-                ), f"Format {metadata_format_name} parsed_fields value for {key} should be string, got {type(value)}"
+                assert isinstance(value, str), (
+                    f"Format {metadata_format_name} parsed_fields value for {key} should be string, got {type(value)}"
+                )

{audiometa_python-1.4.2 → audiometa_python-1.4.3}/audiometa/test/tests/integration/metadata_field/disc_number/test_writing.py

@@ -1,7 +1,9 @@
 import pytest
 
 from audiometa import get_unified_metadata_field, update_metadata
+from audiometa.test.helpers.id3v2.id3v2_metadata_setter import ID3v2MetadataSetter
 from audiometa.test.helpers.temp_file_with_metadata import temp_file_with_metadata
+from audiometa.test.helpers.vorbis.vorbis_metadata_setter import VorbisMetadataSetter
 from audiometa.utils.metadata_format import MetadataFormat
 from audiometa.utils.unified_metadata_key import UnifiedMetadataKey
 
@@ -68,6 +70,34 @@ class TestDiscNumberWriting:
             assert disc_number == 1
             assert disc_total is None
 
+    def test_id3v2_update_disc_number_preserves_total_from_hyphen_tpos(self):
+        with temp_file_with_metadata({}, "mp3") as test_file:
+            ID3v2MetadataSetter.set_metadata(test_file, {"disc_number": "1-2"})
+
+            update_metadata(
+                test_file,
+                {UnifiedMetadataKey.DISC_NUMBER: 5},
+                metadata_format=MetadataFormat.ID3V2,
+            )
+            disc_number = get_unified_metadata_field(test_file, UnifiedMetadataKey.DISC_NUMBER)
+            disc_total = get_unified_metadata_field(test_file, UnifiedMetadataKey.DISC_TOTAL)
+            assert disc_number == 5
+            assert disc_total == 2
+
+    def test_id3v2_update_disc_total_preserves_disc_number_from_hyphen_tpos(self):
+        with temp_file_with_metadata({}, "mp3") as test_file:
+            ID3v2MetadataSetter.set_metadata(test_file, {"disc_number": "1-2"})
+
+            update_metadata(
+                test_file,
+                {UnifiedMetadataKey.DISC_TOTAL: 4},
+                metadata_format=MetadataFormat.ID3V2,
+            )
+            disc_number = get_unified_metadata_field(test_file, UnifiedMetadataKey.DISC_NUMBER)
+            disc_total = get_unified_metadata_field(test_file, UnifiedMetadataKey.DISC_TOTAL)
+            assert disc_number == 1
+            assert disc_total == 4
+
     def test_vorbis_disc_number_writes_separate_fields(self):
         with temp_file_with_metadata({}, "flac") as test_file:
             update_metadata(
@@ -80,6 +110,58 @@ class TestDiscNumberWriting:
             assert disc_number == 1
             assert disc_total == 2
 
+    @pytest.mark.parametrize(
+        "initial_disc_number",
+        ["1/2", "1-2"],
+    )
+    def test_vorbis_update_disc_number_preserves_total_from_combined_discnumber(self, initial_disc_number):
+        with temp_file_with_metadata({}, "flac") as test_file:
+            VorbisMetadataSetter.set_tag(test_file, "DISCNUMBER", initial_disc_number)
+
+            update_metadata(
+                test_file,
+                {UnifiedMetadataKey.DISC_NUMBER: 5},
+                metadata_format=MetadataFormat.VORBIS,
+            )
+            disc_number = get_unified_metadata_field(test_file, UnifiedMetadataKey.DISC_NUMBER)
+            disc_total = get_unified_metadata_field(test_file, UnifiedMetadataKey.DISC_TOTAL)
+            assert disc_number == 5
+            assert disc_total == 2
+
+    def test_vorbis_update_disc_number_preserves_explicit_total_when_conflicting(self):
+        with temp_file_with_metadata({}, "flac") as test_file:
+            VorbisMetadataSetter.set_tag(test_file, "DISCNUMBER", "1/3")
+            VorbisMetadataSetter.set_tag(test_file, "DISCTOTAL", "2")
+
+            update_metadata(
+                test_file,
+                {UnifiedMetadataKey.DISC_NUMBER: 5},
+                metadata_format=MetadataFormat.VORBIS,
+            )
+            disc_number = get_unified_metadata_field(test_file, UnifiedMetadataKey.DISC_NUMBER)
+            disc_total = get_unified_metadata_field(test_file, UnifiedMetadataKey.DISC_TOTAL)
+            assert disc_number == 5
+            assert disc_total == 2
+
+    @pytest.mark.parametrize(
+        "invalid_total",
+        ["bogus", "-1"],
+    )
+    def test_vorbis_update_disc_number_ignores_invalid_explicit_total_and_preserves_embedded(self, invalid_total):
+        with temp_file_with_metadata({}, "flac") as test_file:
+            VorbisMetadataSetter.set_tag(test_file, "DISCNUMBER", "1/2")
+            VorbisMetadataSetter.set_tag(test_file, "DISCTOTAL", invalid_total)
+
+            update_metadata(
+                test_file,
+                {UnifiedMetadataKey.DISC_NUMBER: 5},
+                metadata_format=MetadataFormat.VORBIS,
+            )
+            disc_number = get_unified_metadata_field(test_file, UnifiedMetadataKey.DISC_NUMBER)
+            disc_total = get_unified_metadata_field(test_file, UnifiedMetadataKey.DISC_TOTAL)
+            assert disc_number == 5
+            assert disc_total == 2
+
     def test_id3v2_disc_number_max_value_truncated(self):
         with temp_file_with_metadata({}, "mp3") as test_file:
             update_metadata(