audiometa-python 0.6.0__py3-none-any.whl

audiometa/test/tests/integration/delete_all_metadata/test_basic_functionality.py

@@ -0,0 +1,47 @@
+import pytest
+
+from audiometa import delete_all_metadata
+from audiometa.test.helpers.temp_file_with_metadata import temp_file_with_metadata
+
+
+@pytest.mark.integration
+class TestDeleteAllMetadataBasic:
+    def test_delete_all_metadata_file_with_no_metadata(self):
+        with temp_file_with_metadata({}, "mp3") as test_file:
+            # Delete metadata from file that has no metadata
+            result = delete_all_metadata(test_file)
+            assert result is True
+
+    def test_delete_all_metadata_id3v2_version_specific(self):
+        # First add some metadata using external script
+        test_metadata = {"title": "Test Title", "artist": "Test Artist"}
+        with temp_file_with_metadata(test_metadata, "mp3") as test_file:
+            # Delete metadata with specific ID3v2 version
+            result = delete_all_metadata(test_file, id3v2_version=(2, 3, 0))
+            assert result is True
+
+    def test_delete_all_metadata_return_value_success(self):
+        # First add some metadata using external script
+        test_metadata = {"title": "Test Title", "artist": "Test Artist"}
+        with temp_file_with_metadata(test_metadata, "mp3") as test_file:
+            result = delete_all_metadata(test_file)
+            assert result is True
+            assert isinstance(result, bool)
+
+    def test_delete_all_metadata_preserves_audio_data(self):
+        # First add some metadata using external script
+        test_metadata = {"title": "Test Title", "artist": "Test Artist"}
+        with temp_file_with_metadata(test_metadata, "mp3") as test_file:
+            # Get file size with metadata
+            with_metadata_size = test_file.stat().st_size
+
+            # Delete all metadata
+            result = delete_all_metadata(test_file)
+            assert result is True
+
+            # Verify file size decreased (metadata headers removed)
+            after_deletion_size = test_file.stat().st_size
+            assert after_deletion_size < with_metadata_size
+
+            # Verify the file is still valid (not corrupted)
+            assert after_deletion_size > 0

audiometa/test/tests/integration/delete_all_metadata/test_error_handling.py

@@ -0,0 +1,24 @@
+import pytest
+
+from audiometa import delete_all_metadata
+from audiometa.exceptions import FileTypeNotSupportedError
+from audiometa.test.helpers.temp_file_with_metadata import temp_file_with_metadata
+
+
+@pytest.mark.integration
+class TestDeleteAllMetadataErrorHandling:
+    def test_delete_all_metadata_unsupported_file_type(self):
+        # Create a file with unsupported extension
+        with temp_file_with_metadata({}, "mp3") as temp_audio_file_path:
+            temp_audio_file_path.write_bytes(b"fake audio content")
+            txt_file_path = temp_audio_file_path.with_suffix(".txt")
+            txt_file_path.write_bytes(b"fake audio content")
+
+            with pytest.raises(FileTypeNotSupportedError):
+                delete_all_metadata(str(txt_file_path))
+
+    def test_delete_all_metadata_nonexistent_file(self):
+        nonexistent_file = "nonexistent_file.mp3"
+
+        with pytest.raises(FileNotFoundError):
+            delete_all_metadata(nonexistent_file)

audiometa/test/tests/integration/encoding/__init__.py

@@ -0,0 +1 @@
+"""Integration tests for reading metadata."""

audiometa/test/tests/integration/encoding/test_encoding.py

@@ -0,0 +1,88 @@
+import pytest
+
+from audiometa import get_unified_metadata, update_metadata
+from audiometa.test.helpers.temp_file_with_metadata import temp_file_with_metadata
+from audiometa.utils.metadata_format import MetadataFormat
+from audiometa.utils.unified_metadata_key import UnifiedMetadataKey
+
+
+@pytest.mark.integration
+class TestEncoding:
+    def test_id3v2_3_encoding_support(self):
+        with temp_file_with_metadata({}, "id3v2.3") as test_file:
+            metadata_dict = {
+                UnifiedMetadataKey.TITLE: "Test Title with ASCII",
+                UnifiedMetadataKey.ARTISTS: ["Artist Name"],
+                UnifiedMetadataKey.ALBUM: "Album Name",
+            }
+            update_metadata(test_file, metadata_dict, metadata_format=MetadataFormat.ID3V2, id3v2_version=(2, 3, 0))
+
+            metadata = get_unified_metadata(test_file, metadata_format=MetadataFormat.ID3V2)
+            assert metadata.get(UnifiedMetadataKey.TITLE) == "Test Title with ASCII"
+            assert metadata.get(UnifiedMetadataKey.ARTISTS) == ["Artist Name"]
+            assert metadata.get(UnifiedMetadataKey.ALBUM) == "Album Name"
+
+    def test_id3v2_4_utf8_encoding_support(self):
+        with temp_file_with_metadata({}, "id3v2.4") as test_file:
+            # Test with Unicode characters that require UTF-8
+            unicode_metadata = {
+                UnifiedMetadataKey.TITLE: "Test 中文 العربية русский 🎵",
+                UnifiedMetadataKey.ARTISTS: ["Artist 日本語 한국어"],
+                UnifiedMetadataKey.ALBUM: "Album Ελληνικά ภาษาไทย",
+            }
+
+            update_metadata(test_file, unicode_metadata, metadata_format=MetadataFormat.ID3V2, id3v2_version=(2, 4, 0))
+
+            # Verify the Unicode characters are preserved
+            metadata = get_unified_metadata(test_file)
+            assert metadata.get(UnifiedMetadataKey.TITLE) == "Test 中文 العربية русский 🎵"
+            assert metadata.get(UnifiedMetadataKey.ARTISTS) == ["Artist 日本語 한국어"]
+            assert metadata.get(UnifiedMetadataKey.ALBUM) == "Album Ελληνικά ภาษาไทย"
+
+    def test_id3v1_encoding_support(self):
+        with temp_file_with_metadata({}, "id3v1") as test_file:
+            metadata_dict = {
+                UnifiedMetadataKey.TITLE: "Test Title with ASCII",
+                UnifiedMetadataKey.ARTISTS: ["Artist Name"],
+                UnifiedMetadataKey.ALBUM: "Album Name",
+            }
+            update_metadata(test_file, metadata_dict, metadata_format=MetadataFormat.ID3V1)
+
+            metadata = get_unified_metadata(test_file, metadata_format=MetadataFormat.ID3V1)
+            assert metadata.get(UnifiedMetadataKey.TITLE) == "Test Title with ASCII"
+            assert metadata.get(UnifiedMetadataKey.ARTISTS) == ["Artist Name"]
+            assert metadata.get(UnifiedMetadataKey.ALBUM) == "Album Name"
+
+    def test_riff_utf8_encoding_support(self):
+        with temp_file_with_metadata({}, "wav") as test_file:
+            # Test with Unicode characters that require UTF-8
+            unicode_metadata = {
+                UnifiedMetadataKey.TITLE: "Test 中文 العربية русский 🎵",
+                UnifiedMetadataKey.ARTISTS: ["Artist 日本語 한국어"],
+                UnifiedMetadataKey.ALBUM: "Album Ελληνικά ภาษาไทย",
+            }
+
+            update_metadata(test_file, unicode_metadata, metadata_format=MetadataFormat.RIFF)
+
+            # Verify the Unicode characters are preserved
+            metadata = get_unified_metadata(test_file)
+            assert metadata.get(UnifiedMetadataKey.TITLE) == "Test 中文 العربية русский 🎵"
+            assert metadata.get(UnifiedMetadataKey.ARTISTS) == ["Artist 日本語 한국어"]
+            assert metadata.get(UnifiedMetadataKey.ALBUM) == "Album Ελληνικά ภาษาไทย"
+
+    def test_vorbis_utf8_encoding_support(self):
+        with temp_file_with_metadata({}, "flac") as test_file:
+            # Test with Unicode characters that require UTF-8
+            unicode_metadata = {
+                UnifiedMetadataKey.TITLE: "Test 中文 العربية русский 🎵",
+                UnifiedMetadataKey.ARTISTS: ["Artist 日本語 한국어"],
+                UnifiedMetadataKey.ALBUM: "Album Ελληνικά ภาษาไทย",
+            }
+
+            update_metadata(test_file, unicode_metadata, metadata_format=MetadataFormat.VORBIS)
+
+            # Verify the Unicode characters are preserved
+            metadata = get_unified_metadata(test_file)
+            assert metadata.get(UnifiedMetadataKey.TITLE) == "Test 中文 العربية русский 🎵"
+            assert metadata.get(UnifiedMetadataKey.ARTISTS) == ["Artist 日本語 한국어"]
+            assert metadata.get(UnifiedMetadataKey.ALBUM) == "Album Ελληνικά ภาษาไทย"

audiometa/test/tests/integration/encoding/test_special_characters_edge_cases.py

@@ -0,0 +1,223 @@
+from pathlib import Path
+
+import pytest
+
+from audiometa import get_unified_metadata
+from audiometa.test.helpers.temp_file_with_metadata import temp_file_with_metadata
+from audiometa.test.helpers.vorbis import VorbisMetadataSetter
+from audiometa.test.helpers.vorbis.vorbis_metadata_getter import VorbisMetadataGetter
+from audiometa.utils.unified_metadata_key import UnifiedMetadataKey
+
+
+@pytest.mark.integration
+class TestSpecialCharactersEdgeCases:
+    def test_read_unicode_characters(self):
+        with temp_file_with_metadata({}, "flac") as test_file:
+            VorbisMetadataSetter.set_artists(test_file, ["François", "José", "Müller", "北京"])
+            VorbisMetadataSetter.add_title(test_file, "Café Music 音乐")
+            metadata_title = VorbisMetadataGetter.get_title(test_file)
+            assert metadata_title == "Café Music 音乐"
+
+            unified_metadata = get_unified_metadata(test_file)
+            artists = unified_metadata.get(UnifiedMetadataKey.ARTISTS)
+            title = unified_metadata.get(UnifiedMetadataKey.TITLE)
+
+            assert isinstance(artists, list)
+            assert len(artists) == 4
+            assert "François" in artists
+            assert "José" in artists
+            assert "Müller" in artists
+            assert "北京" in artists
+
+            assert isinstance(title, str)
+            assert title == "Café Music 音乐"
+
+    def test_read_special_punctuation(self):
+        with temp_file_with_metadata({}, "flac") as test_file:
+            VorbisMetadataSetter.set_artists(test_file, ["Artist & Co.", "Band (feat. Singer)", "Group - The Band"])
+            VorbisMetadataSetter.add_title(test_file, "Song (Remix) - Special Edition")
+
+            unified_metadata = get_unified_metadata(test_file)
+            artists = unified_metadata.get(UnifiedMetadataKey.ARTISTS)
+            title = unified_metadata.get(UnifiedMetadataKey.TITLE)
+
+            assert isinstance(artists, list)
+            assert len(artists) == 3
+            assert "Artist & Co." in artists
+            assert "Band (feat. Singer)" in artists
+            assert "Group - The Band" in artists
+
+            assert isinstance(title, str)
+            assert title == "Song (Remix) - Special Edition"
+
+    def test_read_quotes_and_apostrophes(self):
+        with temp_file_with_metadata({}, "flac") as test_file:
+            VorbisMetadataSetter.set_artists(test_file, ["Artist's Band", 'The "Quoted" Band', "It's a Band"])
+            VorbisMetadataSetter.add_title(test_file, 'Don\'t Stop "Believing"')
+
+            unified_metadata = get_unified_metadata(test_file)
+            artists = unified_metadata.get(UnifiedMetadataKey.ARTISTS)
+            title = unified_metadata.get(UnifiedMetadataKey.TITLE)
+
+            assert isinstance(artists, list)
+            assert len(artists) == 3
+            assert "Artist's Band" in artists
+            assert 'The "Quoted" Band' in artists
+            assert "It's a Band" in artists
+
+            assert isinstance(title, str)
+            assert title == 'Don\'t Stop "Believing"'
+
+    def test_read_control_characters(self):
+        with temp_file_with_metadata({}, "flac") as test_file:
+            VorbisMetadataSetter.set_artists(
+                test_file, ["Artist\twith\ttabs", "Band\nwith\nnewlines", "Group\rwith\rcarriage"]
+            )
+            VorbisMetadataSetter.add_title(test_file, "Song\twith\ttabs")
+
+            unified_metadata = get_unified_metadata(test_file)
+            artists = unified_metadata.get(UnifiedMetadataKey.ARTISTS)
+            title = unified_metadata.get(UnifiedMetadataKey.TITLE)
+
+            assert isinstance(artists, list)
+            assert len(artists) == 3
+            assert "Artist\twith\ttabs" in artists
+            assert "Band\nwith\nnewlines" in artists
+            assert "Group\rwith\rcarriage" in artists
+
+            assert isinstance(title, str)
+            assert title == "Song\twith\ttabs"
+
+    def test_read_very_long_strings(self):
+        long_string = "A" * 1000
+        with temp_file_with_metadata({}, "flac") as test_file:
+            VorbisMetadataSetter.set_artists(test_file, [long_string, "Short Artist"])
+            VorbisMetadataSetter.add_title(test_file, "B" * 500)
+
+            unified_metadata = get_unified_metadata(test_file)
+            artists = unified_metadata.get(UnifiedMetadataKey.ARTISTS)
+            title = unified_metadata.get(UnifiedMetadataKey.TITLE)
+
+            assert isinstance(artists, list)
+            assert len(artists) == 2
+            assert long_string in artists
+            assert "Short Artist" in artists
+
+            assert isinstance(title, str)
+            assert title == "B" * 500
+
+    def test_read_mixed_encodings(self):
+        with temp_file_with_metadata({}, "flac") as test_file:
+            VorbisMetadataSetter.set_artists(test_file, ["ASCII Artist", "Français", "Русский", "العربية", "中文"])
+            VorbisMetadataSetter.add_title(test_file, "Mixed 编码 Title")
+
+            unified_metadata = get_unified_metadata(test_file)
+            artists = unified_metadata.get(UnifiedMetadataKey.ARTISTS)
+            title = unified_metadata.get(UnifiedMetadataKey.TITLE)
+
+            assert isinstance(artists, list)
+            assert len(artists) == 5
+            assert "ASCII Artist" in artists
+            assert "Français" in artists
+            assert "Русский" in artists
+            assert "العربية" in artists
+            assert "中文" in artists
+
+            assert isinstance(title, str)
+            assert title == "Mixed 编码 Title"
+
+    def test_read_special_separator_characters(self):
+        with temp_file_with_metadata({}, "flac") as test_file:
+            VorbisMetadataSetter.set_artists(
+                test_file, ["Artist; with; semicolons", "Band, with, commas", "Group|with|pipes"]
+            )
+            VorbisMetadataSetter.add_title(test_file, "Song; with; separators")
+
+            unified_metadata = get_unified_metadata(test_file)
+            artists = unified_metadata.get(UnifiedMetadataKey.ARTISTS)
+            title = unified_metadata.get(UnifiedMetadataKey.TITLE)
+
+            assert isinstance(artists, list)
+            assert len(artists) == 3
+            assert "Artist; with; semicolons" in artists
+            assert "Band, with, commas" in artists
+            assert "Group|with|pipes" in artists
+
+            assert isinstance(title, str)
+            assert title == "Song; with; separators"
+
+    def test_read_html_xml_characters(self):
+        with temp_file_with_metadata({}, "flac") as test_file:
+            VorbisMetadataSetter.set_artists(test_file, ["Artist <tag>", "Band &amp; Co.", "Group &lt;test&gt;"])
+            VorbisMetadataSetter.add_title(test_file, "Song &amp; Title")
+
+            unified_metadata = get_unified_metadata(test_file)
+            artists = unified_metadata.get(UnifiedMetadataKey.ARTISTS)
+            title = unified_metadata.get(UnifiedMetadataKey.TITLE)
+
+            assert isinstance(artists, list)
+            assert len(artists) == 3
+            assert "Artist <tag>" in artists
+            assert "Band &amp; Co." in artists
+            assert "Group &lt;test&gt;" in artists
+
+            assert isinstance(title, str)
+            assert title == "Song &amp; Title"
+
+    def test_read_emoji_characters(self):
+        with temp_file_with_metadata({}, "flac") as test_file:
+            VorbisMetadataSetter.set_artists(test_file, ["Artist 🎵", "Band 🎸", "Group 🎤"])
+            VorbisMetadataSetter.add_title(test_file, "Song 🎶 with 🎵 emojis")
+
+            unified_metadata = get_unified_metadata(test_file)
+            artists = unified_metadata.get(UnifiedMetadataKey.ARTISTS)
+            title = unified_metadata.get(UnifiedMetadataKey.TITLE)
+
+            assert isinstance(artists, list)
+            assert len(artists) == 3
+            assert "Artist 🎵" in artists
+            assert "Band 🎸" in artists
+            assert "Group 🎤" in artists
+
+            assert isinstance(title, str)
+            assert title == "Song 🎶 with 🎵 emojis"
+
+    def test_read_mixed_special_characters(self):
+        with temp_file_with_metadata({}, "flac") as test_file:
+            VorbisMetadataSetter.set_artists(
+                test_file,
+                [
+                    "François & Co. (feat. Müller) 🎵",
+                    'The "Quoted" Band - Special Characters',
+                    "Artist with\nnewlines\tand\ttabs",
+                ],
+            )
+            VorbisMetadataSetter.add_title(test_file, 'Mixed Special 🎵 Characters & "Quotes"')
+
+            unified_metadata = get_unified_metadata(test_file)
+            artists = unified_metadata.get(UnifiedMetadataKey.ARTISTS)
+            title = unified_metadata.get(UnifiedMetadataKey.TITLE)
+
+            assert isinstance(artists, list)
+            assert len(artists) == 3
+            assert "François & Co. (feat. Müller) 🎵" in artists
+            assert 'The "Quoted" Band - Special Characters' in artists
+            assert "Artist with\nnewlines\tand\ttabs" in artists
+
+            assert isinstance(title, str)
+            assert title == 'Mixed Special 🎵 Characters & "Quotes"'
+
+    def test_read_special_characters_from_existing_file(self, sample_mp3_file: Path):
+        # Test reading special characters from a file that already has them
+        # This tests the reading functionality without writing first
+        unified_metadata = get_unified_metadata(sample_mp3_file)
+
+        # Should handle any special characters that might be in the sample file
+        for _key, value in unified_metadata.items():
+            if isinstance(value, str):
+                # Should be able to handle unicode and special characters
+                assert isinstance(value, str)
+            elif isinstance(value, list):
+                for item in value:
+                    if isinstance(item, str):
+                        assert isinstance(item, str)

audiometa/test/tests/integration/get_full_metadata/test_audio_formats.py

@@ -0,0 +1,122 @@
+"""Tests for get_full_metadata function with different audio formats."""
+
+from pathlib import Path
+
+import pytest
+
+from audiometa import get_full_metadata
+
+
+@pytest.mark.integration
+class TestGetFullMetadataAudioFormats:
+    def test_get_full_metadata_mp3_with_metadata(self, sample_mp3_file: Path):
+        result = get_full_metadata(sample_mp3_file)
+
+        # Check structure
+        assert "unified_metadata" in result
+        assert "technical_info" in result
+        assert "metadata_format" in result
+        assert "headers" in result
+        assert "raw_metadata" in result
+        assert "format_priorities" in result
+
+        # Check format priorities
+        assert result["format_priorities"]["file_extension"] == ".mp3"
+        assert "id3v2" in result["format_priorities"]["reading_order"]
+        assert "id3v1" in result["format_priorities"]["reading_order"]
+        assert result["format_priorities"]["writing_format"] == "id3v2"
+
+        # Check technical info
+        tech_info = result["technical_info"]
+        assert "duration_seconds" in tech_info
+        assert "bitrate_bps" in tech_info
+        assert "sample_rate_hz" in tech_info
+        assert "channels" in tech_info
+        assert "file_size_bytes" in tech_info
+        assert "file_extension" in tech_info
+        assert "audio_format_name" in tech_info
+        assert tech_info["file_extension"] == ".mp3"
+        assert tech_info["audio_format_name"] == "MP3"
+        assert tech_info["is_flac_md5_valid"] is None  # Not a FLAC file
+
+        # Check format metadata
+        assert "id3v2" in result["metadata_format"]
+        assert "id3v1" in result["metadata_format"]
+
+        # Check headers
+        assert "id3v2" in result["headers"]
+        assert "id3v1" in result["headers"]
+
+        # Check raw metadata
+        assert "id3v2" in result["raw_metadata"]
+        assert "id3v1" in result["raw_metadata"]
+
+    def test_get_full_metadata_flac_with_metadata(self, sample_flac_file: Path):
+        result = get_full_metadata(sample_flac_file)
+
+        # Check format priorities
+        assert result["format_priorities"]["file_extension"] == ".flac"
+        assert "vorbis" in result["format_priorities"]["reading_order"]
+        assert "id3v2" in result["format_priorities"]["reading_order"]
+        assert "id3v1" in result["format_priorities"]["reading_order"]
+        assert result["format_priorities"]["writing_format"] == "vorbis"
+
+        # Check technical info
+        tech_info = result["technical_info"]
+        assert tech_info["file_extension"] == ".flac"
+        assert tech_info["audio_format_name"] == "FLAC"
+        assert "is_flac_md5_valid" in tech_info  # Should be present for FLAC
+
+        # Check format metadata
+        assert "vorbis" in result["metadata_format"]
+        assert "id3v2" in result["metadata_format"]
+        assert "id3v1" in result["metadata_format"]
+
+        # Check headers
+        assert "vorbis" in result["headers"]
+        assert "id3v2" in result["headers"]
+        assert "id3v1" in result["headers"]
+
+    def test_get_full_metadata_wav_with_metadata(self, sample_wav_file: Path):
+        result = get_full_metadata(sample_wav_file)
+
+        # Check format priorities
+        assert result["format_priorities"]["file_extension"] == ".wav"
+        assert "riff" in result["format_priorities"]["reading_order"]
+        assert "id3v2" in result["format_priorities"]["reading_order"]
+        assert "id3v1" in result["format_priorities"]["reading_order"]
+        assert result["format_priorities"]["writing_format"] == "riff"
+
+        # Check technical info
+        tech_info = result["technical_info"]
+        assert tech_info["file_extension"] == ".wav"
+        assert tech_info["audio_format_name"] == "WAV"
+        assert tech_info["is_flac_md5_valid"] is None  # Not a FLAC file
+
+        # Check format metadata
+        assert "riff" in result["metadata_format"]
+        assert "id3v2" in result["metadata_format"]
+        assert "id3v1" in result["metadata_format"]
+
+        # Check headers
+        assert "riff" in result["headers"]
+        assert "id3v2" in result["headers"]
+        assert "id3v1" in result["headers"]
+
+    def test_get_full_metadata_format_specific_metadata_isolation(self, sample_mp3_file: Path):
+        result = get_full_metadata(sample_mp3_file)
+
+        # Each format should have its own metadata section
+        metadata_format = result["metadata_format"]
+
+        # ID3v2 metadata should be separate from ID3v1
+        if "id3v2" in metadata_format and "id3v1" in metadata_format:
+            id3v2_metadata = metadata_format["id3v2"]
+            id3v1_metadata = metadata_format["id3v1"]
+
+            # They should be separate dictionaries
+            assert isinstance(id3v2_metadata, dict)
+            assert isinstance(id3v1_metadata, dict)
+
+            # They might have different content or structure
+            # This is expected and correct behavior