audiometa-python 0.6.0__py3-none-any.whl

audiometa/test/tests/unit/metadata_managers/metadata_field/multiple_values/writing/test_separator_selection.py

@@ -0,0 +1,142 @@
+import pytest
+
+from audiometa.manager._MetadataManager import _MetadataManager as MetadataManager
+
+
+@pytest.mark.unit
+class TestSeparatorSelection:
+    @pytest.mark.parametrize(
+        ("values", "expected_separator"),
+        [
+            (["Artist One", "Artist Two"], "//"),
+            (["Artist One", "Artist Two", "Artist Three"], "//"),
+            (["Artist;One", "Artist;Two"], "//"),
+            (["Artist,One", "Artist,Two"], "//"),
+            (["Artist/One", "Artist/Two"], "//"),
+            (["Artist\\One", "Artist\\Two"], "//"),
+            (["Artist\\One", "Artist;Two"], "//"),
+            # Cases where // is present, so pick \\\\
+            (["Artist//One", "Artist Two"], "\\\\"),
+            (["Artist//One", "Artist//Two"], "\\\\"),
+            # Cases where // and \\\\ are present, so pick ;
+            (["Artist//One", "Artist\\\\Two"], ";"),
+            (["Artist//One", "Artist\\\\Two", "Artist\\Three"], ";"),
+            # Cases where //, \\\\, \\, ; are present, so pick ,
+            (["Artist//One", "Artist\\\\Two", "Artist\\Three", "Artist;Four"], ","),
+            (["Artist//One", "Artist\\\\Two", "Artist\\Three", "Artist;Four", "Artist/Five"], ","),
+            # Cases with mixed separators
+            (["Artist;One", "Artist,Two", "Artist/Three"], "//"),
+            (["Artist\\One", "Artist;Two", "Artist,Three"], "//"),
+            (["Artist/One", "Artist,Two"], "//"),
+            # Edge cases
+            (["Artist//One;Two", "Artist Three"], "\\\\"),
+            (["Artist\\\\One\\Two", "Artist;Three"], "//"),
+        ],
+    )
+    def test_find_safe_separator(self, values, expected_separator):
+        separator = MetadataManager.find_safe_separator(values)
+        assert separator == expected_separator
+
+        for value in values:
+            assert separator not in value
+
+    def test_find_safe_separator_prioritizes_highest_available(self):
+        # When clean values, uses highest priority
+        values = ["Artist One", "Artist Two"]
+        separator = MetadataManager.find_safe_separator(values)
+        assert separator == "//"
+
+        # When // appears, uses next priority
+        values = ["Artist//One", "Artist Two"]
+        separator = MetadataManager.find_safe_separator(values)
+        assert separator == "\\\\"  # Double backslash
+
+        # When both // and \\ appear, uses semicolon
+        values = ["Artist//One", "Artist\\\\Two"]  # Note: \\\\ in string is \\
+        separator = MetadataManager.find_safe_separator(values)
+        assert separator not in ["//", "\\"]  # Neither // nor single \
+        for value in values:
+            assert separator not in value
+
+    def test_find_safe_separator_no_safe_separator(self):
+        # Test case where all common separators appear
+        # Note: Single backslash is hard to test, so this tests the common separators
+        from audiometa.manager._MetadataManager import METADATA_MULTI_VALUE_SEPARATORS_PRIORITIZED
+
+        values = ["Artist//One", "Artist;Two", "Artist/Three", "Artist,Four"]
+        separator = MetadataManager.find_safe_separator(values)
+        # Should still find a safe separator (backslash-based ones don't appear)
+        assert separator in METADATA_MULTI_VALUE_SEPARATORS_PRIORITIZED
+        for value in values:
+            assert separator not in value
+
+    @pytest.mark.parametrize(
+        "values",
+        [
+            (["Artist//One", "Artist\\\\Two"]),
+            (["Artist;One", "Artist\\Two", "Artist,Three"]),
+            (["Band/Name", "Artist;Separated", "Composer,List"]),
+            (["Artist//With\\Slashes", "Another;With\\Semicolon"]),
+        ],
+    )
+    def test_real_world_artist_names(self, values):
+        separator = MetadataManager.find_safe_separator(values)
+        for value in values:
+            assert separator not in value
+
+    def test_values_with_multiple_separators(self):
+        values = ["Artist//One/Two", "Artist\\\\Three\\Four", "Artist;Five"]
+        separator = MetadataManager.find_safe_separator(values)
+        # Should find a separator that's safe (doesn't appear in values)
+        # Since all common separators appear, it will pick the last available one
+        for value in values:
+            assert separator not in value
+
+    def test_empty_list(self):
+        from audiometa.manager._MetadataManager import METADATA_MULTI_VALUE_SEPARATORS_PRIORITIZED
+
+        separator = MetadataManager.find_safe_separator([])
+        assert separator in METADATA_MULTI_VALUE_SEPARATORS_PRIORITIZED
+
+    def test_single_value(self):
+        separator = MetadataManager.find_safe_separator(["Artist One"])
+        assert separator == "//"
+
+    @pytest.mark.parametrize(
+        ("values", "expected_separator"),
+        [
+            (["DJ Snake", "The Chainsmokers"], "//"),
+            (["Miley Cyrus & Billy Ray Cyrus", "Florida Georgia Line"], "//"),
+            (["Hank Williams, Jr", "Hank Williams"], "//"),
+            # // and / appear, so skips to \\\\
+            (["7//Heaven", "Back/Street"], "\\\\"),
+            # ; and \ appear, so skips to //
+            (["Artist;With\\Backslash", "Another\\Artist"], "//"),
+        ],
+    )
+    def test_complex_artist_names_from_spec_examples(self, values, expected_separator):
+        separator = MetadataManager.find_safe_separator(values)
+        assert separator == expected_separator
+        for value in values:
+            assert separator not in value
+
+    def test_unicode_and_special_characters(self):
+        values = ["Artíst", "Artišt", "Arti§t"]
+        separator = MetadataManager.find_safe_separator(values)
+        assert separator == "//"
+
+    def test_spaces_and_punctuation(self):
+        values = ["Artist One (Feat. Collaborator)", "Artist Two & Friend"]
+        separator = MetadataManager.find_safe_separator(values)
+        assert separator == "//"
+
+    def test_find_safe_separator_empty_and_whitespace_values(self):
+        """Test behavior with empty strings and whitespace."""
+        values = ["", "   ", "Artist One", "Artist Two"]
+        separator = MetadataManager.find_safe_separator(values)
+        assert separator == "//"
+
+        # Empty and whitespace shouldn't affect separator choice
+        for value in values:
+            if value.strip():  # Only check non-empty values
+                assert separator not in value

audiometa/test/tests/unit/metadata_managers/metadata_field/multiple_values/writing/test_value_filtering.py

@@ -0,0 +1,76 @@
+import pytest
+
+from audiometa.manager._MetadataManager import _MetadataManager as MetadataManager
+
+
+@pytest.mark.unit
+class TestValueFiltering:
+    @pytest.mark.parametrize(
+        ("values", "expected_filtered"),
+        [
+            (["Artist One", "Artist Two"], ["Artist One", "Artist Two"]),
+            (["Artist One", ""], ["Artist One"]),
+            (["Artist One", "  "], ["Artist One", "  "]),
+            (["", "Artist Two"], ["Artist Two"]),
+            ([None, "Artist Two"], ["Artist Two"]),
+            (["Artist One", None, "Artist Two"], ["Artist One", "Artist Two"]),
+            ([], []),
+            ([""], []),
+            (["  "], ["  "]),
+            ([None], []),
+            (["", None, "  "], ["  "]),
+        ],
+    )
+    def test_filter_valid_values(self, values, expected_filtered):
+        result = MetadataManager._filter_valid_values(values)
+        assert result == expected_filtered
+
+    def test_filter_valid_values_all_valid(self):
+        values = ["Artist One", "Artist Two", "Artist Three"]
+        result = MetadataManager._filter_valid_values(values)
+        assert result == values
+
+    def test_filter_valid_values_all_invalid(self):
+        values = [None, ""]
+        result = MetadataManager._filter_valid_values(values)
+        assert result == []
+
+    def test_mixed_empty_and_valid_entries_filtering(self):
+        values = ["Valid Artist 1", "", "Valid Artist 2", "", "Valid Artist 3"]
+        result = MetadataManager._filter_valid_values(values)
+        assert result == ["Valid Artist 1", "Valid Artist 2", "Valid Artist 3"]
+
+    def test_filter_valid_values_removes_empty_strings(self):
+        values = ["Valid Artist", "", "Another Valid Artist"]
+        result = MetadataManager._filter_valid_values(values)
+        assert result == ["Valid Artist", "Another Valid Artist"]
+
+    def test_filter_valid_values_only_whitespace_not_empty(self):
+        # filter_valid_values only removes None and empty strings, not whitespace
+        values = ["   ", "\t", "\n"]
+        result = MetadataManager._filter_valid_values(values)
+        assert result == values  # Whitespace strings are not empty
+
+    def test_single_empty_value(self):
+        values = [""]
+        result = MetadataManager._filter_valid_values(values)
+        assert result == []
+
+    def test_none_and_empty_mixed(self):
+        values = [None, "Artist", "", "Another Artist", None]
+        result = MetadataManager._filter_valid_values(values)
+        assert result == ["Artist", "Another Artist"]
+
+    def test_all_none_values_filtered_to_empty_list(self):
+        # Test that [None, None] filters to empty list
+        # This matches the integration test scenario where field is removed
+        values = [None, None]
+        result = MetadataManager._filter_valid_values(values)
+        assert result == []
+
+    def test_mixed_none_and_valid_values_filtering(self):
+        # Test that None values are filtered but valid values remain
+        # This matches the integration test scenario
+        values = ["Artist One", None, "Artist Two", None, "Artist Three"]
+        result = MetadataManager._filter_valid_values(values)
+        assert result == ["Artist One", "Artist Two", "Artist Three"]

audiometa/test/tests/unit/metadata_managers/metadata_field/rating/reading/test_normalization.py

@@ -0,0 +1,152 @@
+from unittest.mock import MagicMock
+
+import pytest
+
+from audiometa.manager._rating_supporting.id3v2._Id3v2Manager import _Id3v2Manager as Id3v2Manager
+from audiometa.manager._rating_supporting.riff._RiffManager import _RiffManager as RiffManager
+from audiometa.manager._rating_supporting.vorbis._VorbisManager import _VorbisManager as VorbisManager
+from audiometa.utils.unified_metadata_key import UnifiedMetadataKey
+
+
+@pytest.mark.unit
+class TestNormalization:
+    @pytest.mark.parametrize(
+        ("metadata_rating_read", "expected_normalized_value"),
+        [
+            (0, 0),
+            (13, 1),
+            (1, 2),
+            (54, 3),
+            (64, 4),
+            (118, 5),
+            (128, 6),
+            (186, 7),
+            (196, 8),
+            (242, 9),
+            (255, 10),
+        ],
+    )
+    def test_base_255_non_proportional(self, metadata_rating_read, expected_normalized_value):
+        id3v2_audio_file = MagicMock()
+        id3v2_manager = Id3v2Manager(audio_file=id3v2_audio_file, normalized_rating_max_value=10)
+        id3v2_normalized_rating = id3v2_manager._get_undirectly_mapped_metadata_value_from_raw_clean_metadata(
+            unified_metadata_key=UnifiedMetadataKey.RATING,
+            raw_clean_metadata_uppercase_keys={
+                Id3v2Manager.Id3TextFrame.RATING: [id3v2_manager.ID3_RATING_APP_EMAIL, metadata_rating_read]
+            },
+        )
+        assert id3v2_normalized_rating == expected_normalized_value
+
+        wave_audio_file = MagicMock()
+        wave_audio_file.file_extension = ".wav"
+        riff_manager = RiffManager(audio_file=wave_audio_file, normalized_rating_max_value=10)
+        riff_normalized_rating = riff_manager._get_undirectly_mapped_metadata_value_from_raw_clean_metadata(
+            unified_metadata_key=UnifiedMetadataKey.RATING,
+            raw_clean_metadata_uppercase_keys={RiffManager.RiffTagKey.RATING: [str(metadata_rating_read)]},
+        )
+        assert riff_normalized_rating == expected_normalized_value
+
+        flac_audio_file = MagicMock()
+        flac_audio_file.file_extension = ".flac"
+        vorbis_manager = VorbisManager(audio_file=flac_audio_file, normalized_rating_max_value=10)
+        vorbis_normalized_rating = vorbis_manager._get_undirectly_mapped_metadata_value_from_raw_clean_metadata(
+            unified_metadata_key=UnifiedMetadataKey.RATING,
+            raw_clean_metadata_uppercase_keys={VorbisManager.VorbisKey.RATING: [metadata_rating_read]},
+        )
+        assert vorbis_normalized_rating == expected_normalized_value
+
+    @pytest.mark.parametrize(
+        ("metadata_rating_read", "expected_normalized_value"),
+        [
+            (0, 0),
+            (10, 1),
+            (20, 2),
+            (30, 3),
+            (40, 4),
+            (50, 5),
+            (60, 6),
+            (70, 7),
+            (80, 8),
+            (90, 9),
+            (100, 10),
+        ],
+    )
+    def test_base_100_proportional(self, metadata_rating_read, expected_normalized_value):
+        # ID3v2
+        id3v2_manager = Id3v2Manager(audio_file=MagicMock(), normalized_rating_max_value=10)
+        id3v2_normalized_rating = id3v2_manager._get_undirectly_mapped_metadata_value_from_raw_clean_metadata(
+            unified_metadata_key=UnifiedMetadataKey.RATING,
+            raw_clean_metadata_uppercase_keys={
+                Id3v2Manager.Id3TextFrame.RATING: [id3v2_manager.ID3_RATING_APP_EMAIL, metadata_rating_read]
+            },
+        )
+        assert id3v2_normalized_rating == expected_normalized_value
+
+        # RIFF / WAV
+        wave_audio_file = MagicMock()
+        wave_audio_file.file_extension = ".wav"
+        riff_manager = RiffManager(audio_file=wave_audio_file, normalized_rating_max_value=10)
+        riff_normalized_rating = riff_manager._get_undirectly_mapped_metadata_value_from_raw_clean_metadata(
+            unified_metadata_key=UnifiedMetadataKey.RATING,
+            raw_clean_metadata_uppercase_keys={RiffManager.RiffTagKey.RATING: [str(metadata_rating_read)]},
+        )
+        assert riff_normalized_rating == expected_normalized_value
+
+        # VORBIS / FLAC
+        flac_audio_file = MagicMock()
+        flac_audio_file.file_extension = ".flac"
+        vorbis_manager = VorbisManager(audio_file=flac_audio_file, normalized_rating_max_value=10)
+        vorbis_normalized_rating = vorbis_manager._get_undirectly_mapped_metadata_value_from_raw_clean_metadata(
+            unified_metadata_key=UnifiedMetadataKey.RATING,
+            raw_clean_metadata_uppercase_keys={VorbisManager.VorbisKey.RATING: [metadata_rating_read]},
+        )
+        assert vorbis_normalized_rating == expected_normalized_value
+
+    @pytest.mark.parametrize(
+        ("metadata_rating_read", "expected_normalized_value"),
+        [
+            (51, 1),
+            (102, 2),
+            (153, 3),
+            (204, 4),
+            (255, 5),
+        ],
+    )
+    def test_base_255_proportional(self, metadata_rating_read, expected_normalized_value):
+        # ID3v2
+        id3v2_manager = Id3v2Manager(audio_file=MagicMock(), normalized_rating_max_value=5)
+        id3v2_normalized_rating = id3v2_manager._get_undirectly_mapped_metadata_value_from_raw_clean_metadata(
+            unified_metadata_key=UnifiedMetadataKey.RATING,
+            raw_clean_metadata_uppercase_keys={
+                Id3v2Manager.Id3TextFrame.RATING: [id3v2_manager.ID3_RATING_APP_EMAIL, metadata_rating_read]
+            },
+        )
+        assert id3v2_normalized_rating == expected_normalized_value
+
+        # RIFF / WAV
+        wave_audio_file = MagicMock()
+        wave_audio_file.file_extension = ".wav"
+        riff_manager = RiffManager(audio_file=wave_audio_file, normalized_rating_max_value=5)
+        riff_normalized_rating = riff_manager._get_undirectly_mapped_metadata_value_from_raw_clean_metadata(
+            unified_metadata_key=UnifiedMetadataKey.RATING,
+            raw_clean_metadata_uppercase_keys={RiffManager.RiffTagKey.RATING: [str(metadata_rating_read)]},
+        )
+        assert riff_normalized_rating == expected_normalized_value
+
+        # VORBIS / FLAC
+        flac_audio_file = MagicMock()
+        flac_audio_file.file_extension = ".flac"
+        vorbis_manager = VorbisManager(audio_file=flac_audio_file, normalized_rating_max_value=5)
+        vorbis_normalized_rating = vorbis_manager._get_undirectly_mapped_metadata_value_from_raw_clean_metadata(
+            unified_metadata_key=UnifiedMetadataKey.RATING,
+            raw_clean_metadata_uppercase_keys={VorbisManager.VorbisKey.RATING: [metadata_rating_read]},
+        )
+        assert vorbis_normalized_rating == expected_normalized_value
+
+    def test_invalid_value(self):
+        manager = Id3v2Manager(audio_file=MagicMock(), normalized_rating_max_value=10)
+        normalized_rating = manager._get_undirectly_mapped_metadata_value_from_raw_clean_metadata(
+            unified_metadata_key=UnifiedMetadataKey.RATING,
+            raw_clean_metadata_uppercase_keys={Id3v2Manager.Id3TextFrame.RATING: [manager.ID3_RATING_APP_EMAIL, 300]},
+        )
+        assert normalized_rating is None

audiometa/test/tests/unit/metadata_managers/metadata_field/rating/reading/test_profiles_values.py

@@ -0,0 +1,23 @@
+import pytest
+
+from audiometa.utils.rating_profiles import RatingReadProfile
+
+
+@pytest.mark.unit
+class TestRatingProfileValues:
+    @pytest.mark.parametrize(
+        ("profile_enum", "expected_values"),
+        [
+            (RatingReadProfile.BASE_255_NON_PROPORTIONAL, (0, 13, 1, 54, 64, 118, 128, 186, 196, 242, 255)),
+            (RatingReadProfile.BASE_100_PROPORTIONAL, (0, 10, 20, 30, 40, 50, 60, 70, 80, 90, 100)),
+            (
+                RatingReadProfile.BASE_255_PROPORTIONAL_TRAKTOR,
+                (None, None, 51, None, 102, None, 153, None, 204, None, 255),
+            ),
+        ],
+    )
+    def test_profile_values(self, profile_enum, expected_values):
+        profile = profile_enum.value
+
+        assert profile == expected_values
+        assert len(profile) == 11  # 0-5 stars (0, 0.5, 1, 1.5, 2, 2.5, 3, 3.5, 4, 4.5, 5)

audiometa/test/tests/unit/metadata_managers/metadata_field/rating/test_rating_validation.py

@@ -0,0 +1,77 @@
+import pytest
+
+from audiometa import validate_metadata_for_update
+from audiometa.exceptions import InvalidMetadataFieldTypeError, InvalidRatingValueError
+from audiometa.utils.unified_metadata_key import UnifiedMetadataKey
+
+
+@pytest.mark.unit
+class TestRatingValidation:
+    """Test rating field validation in validate_metadata_for_update."""
+
+    @pytest.mark.parametrize(
+        "rating",
+        [0, 128, 255],
+    )
+    def test_valid_rating_raw_mode(self, rating):
+        validate_metadata_for_update({UnifiedMetadataKey.RATING: rating})
+
+    @pytest.mark.parametrize(
+        "rating",
+        [1.5, 75.7],
+    )
+    def test_invalid_rating_float_in_raw_mode_raises_error(self, rating):
+        with pytest.raises(InvalidRatingValueError) as exc_info:
+            validate_metadata_for_update({UnifiedMetadataKey.RATING: rating})
+        assert "In raw mode, float values must be whole numbers" in str(exc_info.value)
+
+    @pytest.mark.parametrize(
+        "rating",
+        [0.0, 196.0, 128.0],
+    )
+    def test_valid_rating_whole_number_float_in_raw_mode(self, rating):
+        # Whole-number floats like 0.0, 196.0 are accepted and converted to int
+        validate_metadata_for_update({UnifiedMetadataKey.RATING: rating})
+
+    @pytest.mark.parametrize(
+        "rating",
+        [50, 0, 100, 1.5, 7.5, 50.0],
+    )
+    def test_valid_rating_normalized_mode(self, rating):
+        validate_metadata_for_update({UnifiedMetadataKey.RATING: rating}, normalized_rating_max_value=100)
+
+    @pytest.mark.parametrize(
+        "rating",
+        [-1, -100, -0.5, -1.5],
+    )
+    def test_invalid_rating_negative_raises_error(self, rating):
+        with pytest.raises(InvalidRatingValueError):
+            validate_metadata_for_update({UnifiedMetadataKey.RATING: rating})
+
+    @pytest.mark.parametrize(
+        "rating",
+        [101, 100.1, 101.5],
+    )
+    def test_invalid_rating_over_max_raises_error(self, rating):
+        with pytest.raises(InvalidRatingValueError):
+            validate_metadata_for_update({UnifiedMetadataKey.RATING: rating}, normalized_rating_max_value=100)
+
+    @pytest.mark.parametrize(
+        "rating",
+        [110, 110.5],
+    )
+    def test_invalid_rating_profile_value_raises_error(self, rating):
+        # Values > max that would map to invalid star rating indices (> 10)
+        with pytest.raises(InvalidRatingValueError):
+            validate_metadata_for_update({UnifiedMetadataKey.RATING: rating}, normalized_rating_max_value=100)
+
+    @pytest.mark.parametrize(
+        "invalid_value",
+        ["invalid", {}],
+    )
+    def test_invalid_rating_type_raises_error(self, invalid_value):
+        with pytest.raises(InvalidMetadataFieldTypeError):
+            validate_metadata_for_update({UnifiedMetadataKey.RATING: invalid_value})
+
+    def test_rating_none_is_allowed(self):
+        validate_metadata_for_update({UnifiedMetadataKey.RATING: None})

audiometa/test/tests/unit/metadata_managers/metadata_field/rating/writing/test_configuration_error.py

@@ -0,0 +1,43 @@
+from unittest.mock import MagicMock
+
+import pytest
+
+from audiometa.exceptions import ConfigurationError
+from audiometa.manager._rating_supporting.id3v2._Id3v2Manager import _Id3v2Manager as Id3v2Manager
+from audiometa.manager._rating_supporting.riff._RiffManager import _RiffManager as RiffManager
+from audiometa.manager._rating_supporting.vorbis._VorbisManager import _VorbisManager as VorbisManager
+
+
+@pytest.mark.unit
+class TestConfigurationError:
+    def test_convert_normalized_rating_raises_config_error_when_max_value_none(
+        self,
+    ):
+        id3v2_audio_file = MagicMock()
+        id3v2_manager = Id3v2Manager(audio_file=id3v2_audio_file, normalized_rating_max_value=None)
+
+        with pytest.raises(ConfigurationError) as exc_info:
+            id3v2_manager._convert_normalized_rating_to_file_rating(normalized_rating=5.0)
+        assert "normalized_rating_max_value must be set" in str(exc_info.value)
+
+    def test_convert_normalized_rating_to_file_rating_raises_configuration_error_for_riff_manager(
+        self,
+    ):
+        wave_audio_file = MagicMock()
+        wave_audio_file.file_extension = ".wav"
+        riff_manager = RiffManager(audio_file=wave_audio_file, normalized_rating_max_value=None)
+
+        with pytest.raises(ConfigurationError) as exc_info:
+            riff_manager._convert_normalized_rating_to_file_rating(normalized_rating=5.0)
+        assert "normalized_rating_max_value must be set" in str(exc_info.value)
+
+    def test_convert_normalized_rating_to_file_rating_raises_configuration_error_for_vorbis_manager(
+        self,
+    ):
+        flac_audio_file = MagicMock()
+        flac_audio_file.file_extension = ".flac"
+        vorbis_manager = VorbisManager(audio_file=flac_audio_file, normalized_rating_max_value=None)
+
+        with pytest.raises(ConfigurationError) as exc_info:
+            vorbis_manager._convert_normalized_rating_to_file_rating(normalized_rating=5.0)
+        assert "normalized_rating_max_value must be set" in str(exc_info.value)