audiometa-python 0.6.0__py3-none-any.whl

audiometa/test/tests/e2e/cli/read/test_multiple_files.py

@@ -0,0 +1,149 @@
+import json
+import subprocess
+import sys
+
+import pytest
+
+from audiometa.test.helpers.temp_file_with_metadata import temp_file_with_metadata
+
+
+@pytest.mark.e2e
+class TestCLIReadMultipleFiles:
+    def test_cli_read_multiple_files(self):
+        with (
+            temp_file_with_metadata({"title": "File One"}, "mp3") as file1,
+            temp_file_with_metadata({"title": "File Two"}, "mp3") as file2,
+        ):
+            result = subprocess.run(
+                [
+                    sys.executable,
+                    "-m",
+                    "audiometa",
+                    "read",
+                    str(file1),
+                    str(file2),
+                    "--format",
+                    "json",
+                ],
+                capture_output=True,
+                text=True,
+                check=False,
+            )
+            assert result.returncode == 0
+            # When reading multiple files, each file outputs a separate JSON object
+            # JSON objects can span multiple lines, so we need to parse them properly
+            output = result.stdout.strip()
+            if output:
+                # Try to parse the first complete JSON object
+                # Find the first complete JSON object by counting braces
+                brace_count = 0
+                start_idx = 0
+                for i, char in enumerate(output):
+                    if char == "{":
+                        brace_count += 1
+                    elif char == "}":
+                        brace_count -= 1
+                        if brace_count == 0:
+                            # Found complete JSON object
+                            first_json_str = output[start_idx : i + 1]
+                            data = json.loads(first_json_str)
+                            assert isinstance(data, dict)
+                            assert "unified_metadata" in data or "metadata_format" in data
+                            break
+
+    def test_cli_read_multiple_files_with_continue_on_error(self, tmp_path):
+        nonexistent_file = tmp_path / "nonexistent.mp3"
+        with temp_file_with_metadata({"title": "Valid File"}, "mp3") as valid_file:
+            result = subprocess.run(
+                [
+                    sys.executable,
+                    "-m",
+                    "audiometa",
+                    "read",
+                    str(nonexistent_file),
+                    str(valid_file),
+                    "--continue-on-error",
+                    "--format",
+                    "json",
+                ],
+                capture_output=True,
+                text=True,
+                check=False,
+            )
+            assert result.returncode == 0
+            # When reading multiple files, each file outputs a separate JSON object
+            # JSON objects can span multiple lines, so we need to parse them properly
+            output = result.stdout.strip()
+            if output:
+                # Try to parse the first complete JSON object
+                brace_count = 0
+                start_idx = 0
+                for i, char in enumerate(output):
+                    if char == "{":
+                        if brace_count == 0:
+                            start_idx = i
+                        brace_count += 1
+                    elif char == "}":
+                        brace_count -= 1
+                        if brace_count == 0:
+                            # Found complete JSON object
+                            try:
+                                first_json_str = output[start_idx : i + 1]
+                                data = json.loads(first_json_str)
+                                assert isinstance(data, dict)
+                                break
+                            except json.JSONDecodeError:
+                                continue
+
+    def test_cli_read_glob_pattern(self, tmp_path):
+        # Use a dedicated temp directory to avoid matching other temp files
+        test_dir = tmp_path / "glob_test"
+        test_dir.mkdir()
+
+        with temp_file_with_metadata({"title": "Pattern File 1"}, "mp3") as file1:
+            file1_name = file1.name
+            test_file1 = test_dir / file1_name
+            import shutil
+
+            shutil.copy2(file1, test_file1)
+            with temp_file_with_metadata({"title": "Pattern File 2"}, "mp3") as temp_file2:
+                file2_name = "pattern_file_2.mp3"
+                test_file2 = test_dir / file2_name
+                shutil.copy2(temp_file2, test_file2)
+
+                result = subprocess.run(
+                    [
+                        sys.executable,
+                        "-m",
+                        "audiometa",
+                        "read",
+                        str(test_dir / "*.mp3"),
+                        "--format",
+                        "json",
+                        "--continue-on-error",
+                    ],
+                    capture_output=True,
+                    text=True,
+                    check=False,
+                )
+                assert result.returncode == 0
+                # When reading multiple files, each file outputs a separate JSON object
+                # JSON objects can span multiple lines, so we need to parse them properly
+                output = result.stdout.strip()
+                if output:
+                    # Try to parse the first complete JSON object
+                    brace_count = 0
+                    start_idx = 0
+                    for i, char in enumerate(output):
+                        if char == "{":
+                            if brace_count == 0:
+                                start_idx = i
+                            brace_count += 1
+                        elif char == "}":
+                            brace_count -= 1
+                            if brace_count == 0:
+                                # Found complete JSON object
+                                first_json_str = output[start_idx : i + 1]
+                                data = json.loads(first_json_str)
+                                assert isinstance(data, dict)
+                                break

audiometa/test/tests/e2e/cli/read/test_options.py

@@ -0,0 +1,88 @@
+import json
+import subprocess
+import sys
+
+import pytest
+
+from audiometa.test.helpers.temp_file_with_metadata import temp_file_with_metadata
+
+
+@pytest.mark.e2e
+class TestCLIReadOptions:
+    def test_cli_read_no_headers(self):
+        with temp_file_with_metadata({"title": "Test Title"}, "mp3") as test_file:
+            result = subprocess.run(
+                [sys.executable, "-m", "audiometa", "read", str(test_file), "--no-headers", "--format", "json"],
+                capture_output=True,
+                text=True,
+                check=False,
+            )
+            assert result.returncode == 0
+            data = json.loads(result.stdout)
+            assert "unified_metadata" in data
+            # When --no-headers is used, headers should be empty dict, not absent
+            assert "headers" in data
+            assert data["headers"] == {}
+
+    def test_cli_read_no_technical(self):
+        with temp_file_with_metadata({"title": "Test Title"}, "mp3") as test_file:
+            result = subprocess.run(
+                [sys.executable, "-m", "audiometa", "read", str(test_file), "--no-technical", "--format", "json"],
+                capture_output=True,
+                text=True,
+                check=False,
+            )
+            assert result.returncode == 0
+            data = json.loads(result.stdout)
+            assert "unified_metadata" in data
+            # When --no-technical is used, technical_info should be empty dict, not absent
+            assert "technical_info" in data
+            assert data["technical_info"] == {}
+
+    def test_cli_read_no_headers_no_technical(self):
+        with temp_file_with_metadata({"title": "Test Title"}, "mp3") as test_file:
+            result = subprocess.run(
+                [
+                    sys.executable,
+                    "-m",
+                    "audiometa",
+                    "read",
+                    str(test_file),
+                    "--no-headers",
+                    "--no-technical",
+                    "--format",
+                    "json",
+                ],
+                capture_output=True,
+                text=True,
+                check=False,
+            )
+            assert result.returncode == 0
+            data = json.loads(result.stdout)
+            assert "unified_metadata" in data
+            # When --no-headers and --no-technical are used, these should be empty dicts, not absent
+            assert "headers" in data
+            assert data["headers"] == {}
+            assert "technical_info" in data
+            assert data["technical_info"] == {}
+
+    def test_cli_read_with_all_options(self):
+        with temp_file_with_metadata({"title": "Test Title", "artist": "Test Artist"}, "mp3") as test_file:
+            result = subprocess.run(
+                [
+                    sys.executable,
+                    "-m",
+                    "audiometa",
+                    "read",
+                    str(test_file),
+                    "--no-headers",
+                    "--no-technical",
+                    "--format",
+                    "table",
+                ],
+                capture_output=True,
+                text=True,
+                check=False,
+            )
+            assert result.returncode == 0
+            assert "UNIFIED METADATA" in result.stdout

audiometa/test/tests/e2e/cli/read/test_unified.py

@@ -0,0 +1,84 @@
+import json
+import subprocess
+import sys
+
+import pytest
+
+from audiometa.test.helpers.temp_file_with_metadata import temp_file_with_metadata
+
+
+@pytest.mark.e2e
+class TestCLIReadUnified:
+    def test_cli_unified_output(self, sample_mp3_file):
+        result = subprocess.run(
+            [sys.executable, "-m", "audiometa", "unified", str(sample_mp3_file), "--format", "json"],
+            capture_output=True,
+            text=True,
+            check=False,
+        )
+        assert result.returncode == 0
+        data = json.loads(result.stdout)
+        assert isinstance(data, dict)
+        assert "unified_metadata" not in data
+        assert "headers" not in data
+        assert "technical_info" not in data
+
+    def test_cli_unified_with_metadata(self):
+        with temp_file_with_metadata({"title": "Unified Test", "artist": "Unified Artist"}, "mp3") as test_file:
+            result = subprocess.run(
+                [sys.executable, "-m", "audiometa", "unified", str(test_file), "--format", "json"],
+                capture_output=True,
+                text=True,
+                check=False,
+            )
+            assert result.returncode == 0
+            data = json.loads(result.stdout)
+            assert isinstance(data, dict)
+            assert data.get("title") == "Unified Test"
+            assert data.get("artists") == ["Unified Artist"]
+
+    def test_cli_unified_table_format(self):
+        with temp_file_with_metadata({"title": "Table Test", "artist": "Table Artist"}, "mp3") as test_file:
+            result = subprocess.run(
+                [sys.executable, "-m", "audiometa", "unified", str(test_file), "--format", "table"],
+                capture_output=True,
+                text=True,
+                check=False,
+            )
+            assert result.returncode == 0
+            assert "title" in result.stdout.lower() or "Table Test" in result.stdout
+
+    def test_cli_unified_output_to_file(self, tmp_path):
+        with temp_file_with_metadata({"title": "File Test"}, "mp3") as test_file:
+            output_file = tmp_path / "unified.json"
+            result = subprocess.run(
+                [
+                    sys.executable,
+                    "-m",
+                    "audiometa",
+                    "unified",
+                    str(test_file),
+                    "--output",
+                    str(output_file),
+                ],
+                capture_output=True,
+                text=True,
+                check=False,
+            )
+            assert result.returncode == 0
+            assert output_file.exists()
+            with output_file.open() as f:
+                data = json.load(f)
+            assert isinstance(data, dict)
+
+    def test_cli_with_spaces_in_filename_unified(self):
+        with temp_file_with_metadata({}, "mp3") as test_file:
+            result = subprocess.run(
+                [sys.executable, "-m", "audiometa", "unified", str(test_file), "--format", "json"],
+                capture_output=True,
+                text=True,
+                check=False,
+            )
+            assert result.returncode == 0
+            data = json.loads(result.stdout)
+            assert isinstance(data, dict)

audiometa/test/tests/e2e/cli/test_delete.py

@@ -0,0 +1,20 @@
+import subprocess
+import sys
+
+import pytest
+
+from audiometa.test.helpers.temp_file_with_metadata import temp_file_with_metadata
+
+
+@pytest.mark.e2e
+class TestCLIDelete:
+    def test_cli_delete_metadata(self):
+        with temp_file_with_metadata({}, "mp3") as test_file:
+            result = subprocess.run(
+                [sys.executable, "-m", "audiometa", "delete", str(test_file)],
+                capture_output=True,
+                text=True,
+                check=False,
+            )
+            assert result.returncode == 0
+            assert "Deleted metadata" in result.stdout or "No metadata found" in result.stderr

audiometa/test/tests/e2e/cli/test_formatting.py

@@ -0,0 +1,31 @@
+import json
+
+import pytest
+
+from audiometa.cli import format_as_table, format_output
+
+
+@pytest.mark.e2e
+class TestCLIFormatting:
+    def test_format_output_json(self):
+        data = {"title": "Test Song", "artist": "Test Artist"}
+        result = format_output(data, "json")
+        parsed = json.loads(result)
+        assert parsed == data
+
+    def test_format_output_yaml(self):
+        data = {"title": "Test Song", "artist": "Test Artist"}
+        result = format_output(data, "yaml")
+        # Should fall back to JSON if PyYAML not available
+        assert "Test Song" in result
+
+    def test_format_output_table(self):
+        data = {
+            "unified_metadata": {"title": "Test Song", "artist": "Test Artist"},
+            "technical_info": {"duration_seconds": 180, "bitrate_bps": 320000},
+        }
+        result = format_as_table(data)
+        assert "Test Song" in result
+        assert "Test Artist" in result
+        assert "180" in result
+        assert "320" in result

audiometa/test/tests/e2e/cli/test_help.py

@@ -0,0 +1,41 @@
+import subprocess
+import sys
+
+import pytest
+
+
+@pytest.mark.e2e
+class TestCLIHelp:
+    def test_cli_help(self):
+        result = subprocess.run([sys.executable, "-m", "audiometa"], capture_output=True, text=True, check=False)
+        assert result.returncode == 1  # Should exit with error
+        assert "usage:" in result.stdout.lower() or "help" in result.stdout.lower()
+
+    def test_cli_read_help(self):
+        result = subprocess.run(
+            [sys.executable, "-m", "audiometa", "read", "--help"], capture_output=True, text=True, check=False
+        )
+        assert result.returncode == 0
+        assert "read" in result.stdout.lower()
+
+    def test_cli_unified_help(self):
+        result = subprocess.run(
+            [sys.executable, "-m", "audiometa", "unified", "--help"], capture_output=True, text=True, check=False
+        )
+        assert result.returncode == 0
+        assert "unified" in result.stdout.lower()
+
+    def test_cli_write_help(self):
+        result = subprocess.run(
+            [sys.executable, "-m", "audiometa", "write", "--help"], capture_output=True, text=True, check=False
+        )
+        assert result.returncode == 0
+        assert "write" in result.stdout.lower()
+        assert "force-format" in result.stdout.lower()
+
+    def test_cli_delete_help(self):
+        result = subprocess.run(
+            [sys.executable, "-m", "audiometa", "delete", "--help"], capture_output=True, text=True, check=False
+        )
+        assert result.returncode == 0
+        assert "delete" in result.stdout.lower()

audiometa/test/tests/e2e/cli/write/test_basic.py

@@ -0,0 +1,51 @@
+import subprocess
+import sys
+
+import pytest
+
+from audiometa.test.helpers.temp_file_with_metadata import temp_file_with_metadata
+
+
+@pytest.mark.e2e
+class TestCLIWriteBasic:
+    def test_cli_write_no_metadata(self, sample_mp3_file):
+        result = subprocess.run(
+            [sys.executable, "-m", "audiometa", "write", str(sample_mp3_file)],
+            capture_output=True,
+            text=True,
+            check=False,
+        )
+        assert result.returncode == 1
+        assert "no metadata fields specified" in result.stderr.lower()
+
+    def test_cli_write_basic_metadata(self):
+        with temp_file_with_metadata({}, "mp3") as test_file:
+            result = subprocess.run(
+                [sys.executable, "-m", "audiometa", "write", str(test_file), "--title", "CLI Test Title"],
+                capture_output=True,
+                text=True,
+                check=False,
+            )
+            assert result.returncode == 0
+            assert "Updated metadata" in result.stdout
+
+    def test_cli_with_spaces_in_filename_write(self):
+        with temp_file_with_metadata({}, "mp3") as test_file:
+            result = subprocess.run(
+                [
+                    sys.executable,
+                    "-m",
+                    "audiometa",
+                    "write",
+                    str(test_file),
+                    "--title",
+                    "Test Title",
+                    "--artist",
+                    "Test Artist",
+                ],
+                capture_output=True,
+                text=True,
+                check=False,
+            )
+            assert result.returncode == 0
+            assert "Updated metadata" in result.stdout

audiometa/test/tests/e2e/cli/write/test_comprehensive.py

@@ -0,0 +1,210 @@
+import subprocess
+import sys
+
+import pytest
+
+from audiometa import get_unified_metadata
+from audiometa.test.helpers.temp_file_with_metadata import temp_file_with_metadata
+from audiometa.utils.unified_metadata_key import UnifiedMetadataKey
+
+
+@pytest.mark.e2e
+class TestCLIWriteComprehensive:
+    def test_cli_write_all_fields_comprehensive(self):
+        with temp_file_with_metadata({}, "mp3") as test_file:
+            result = subprocess.run(
+                [
+                    sys.executable,
+                    "-m",
+                    "audiometa",
+                    "write",
+                    str(test_file),
+                    "--title",
+                    "Comprehensive Test Title",
+                    "--artist",
+                    "Artist One",
+                    "--artist",
+                    "Artist Two",
+                    "--album",
+                    "Test Album",
+                    "--album-artist",
+                    "Album Artist",
+                    "--year",
+                    "2024",
+                    "--genre",
+                    "Rock",
+                    "--genre",
+                    "Blues",
+                    "--track-number",
+                    "5/12",
+                    "--disc-number",
+                    "1",
+                    "--disc-total",
+                    "2",
+                    "--rating",
+                    "85",
+                    "--bpm",
+                    "120",
+                    "--language",
+                    "eng",
+                    "--composer",
+                    "Composer One",
+                    "--composer",
+                    "Composer Two",
+                    "--publisher",
+                    "Test Publisher",
+                    "--copyright",
+                    "© 2024",
+                    "--lyrics",
+                    "Test lyrics",
+                    "--comment",
+                    "Test comment",
+                    "--replaygain",
+                    "+2.5 dB",
+                    "--archival-location",
+                    "Archive",
+                    "--isrc",
+                    "USRC17607839",
+                ],
+                capture_output=True,
+                text=True,
+                check=False,
+            )
+            assert result.returncode == 0
+
+            metadata = get_unified_metadata(test_file)
+            assert metadata.get(UnifiedMetadataKey.TITLE) == "Comprehensive Test Title"
+            assert metadata.get(UnifiedMetadataKey.ARTISTS) == ["Artist One", "Artist Two"]
+            assert metadata.get(UnifiedMetadataKey.ALBUM) == "Test Album"
+            assert metadata.get(UnifiedMetadataKey.ALBUM_ARTISTS) == ["Album Artist"]
+            assert metadata.get(UnifiedMetadataKey.RELEASE_DATE) == "2024"
+            assert metadata.get(UnifiedMetadataKey.GENRES_NAMES) == ["Rock", "Blues"]
+            assert metadata.get(UnifiedMetadataKey.TRACK_NUMBER) == "5/12"
+            assert metadata.get(UnifiedMetadataKey.DISC_NUMBER) == 1
+            assert metadata.get(UnifiedMetadataKey.DISC_TOTAL) == 2
+            assert metadata.get(UnifiedMetadataKey.RATING) == 85
+            assert metadata.get(UnifiedMetadataKey.BPM) == 120
+            assert metadata.get(UnifiedMetadataKey.LANGUAGE) == "eng"
+            assert metadata.get(UnifiedMetadataKey.COMPOSERS) == ["Composer One", "Composer Two"]
+            assert metadata.get(UnifiedMetadataKey.PUBLISHER) == "Test Publisher"
+            assert metadata.get(UnifiedMetadataKey.COPYRIGHT) == "© 2024"
+            assert metadata.get(UnifiedMetadataKey.UNSYNCHRONIZED_LYRICS) == "Test lyrics"
+            assert metadata.get(UnifiedMetadataKey.COMMENT) == "Test comment"
+            assert metadata.get(UnifiedMetadataKey.REPLAYGAIN) == "+2.5 dB"
+            assert metadata.get(UnifiedMetadataKey.ISRC) == "USRC17607839"
+            # ARCHIVAL_LOCATION is not supported by ID3v2 format (MP3)
+            # It's only supported by Vorbis (FLAC)
+
+    def test_cli_write_flac_all_fields(self):
+        with temp_file_with_metadata({}, "flac") as test_file:
+            result = subprocess.run(
+                [
+                    sys.executable,
+                    "-m",
+                    "audiometa",
+                    "write",
+                    str(test_file),
+                    "--title",
+                    "FLAC Test",
+                    "--artist",
+                    "FLAC Artist",
+                    "--album",
+                    "FLAC Album",
+                    "--track-number",
+                    "3/10",
+                    "--disc-number",
+                    "1",
+                    "--disc-total",
+                    "2",
+                    "--bpm",
+                    "140",
+                    "--language",
+                    "eng",
+                    "--composer",
+                    "FLAC Composer",
+                    "--publisher",
+                    "FLAC Publisher",
+                    "--copyright",
+                    "© FLAC",
+                    "--lyrics",
+                    "FLAC lyrics",
+                    "--comment",
+                    "FLAC comment",
+                    "--isrc",
+                    "FRXXX1800001",
+                ],
+                capture_output=True,
+                text=True,
+                check=False,
+            )
+            assert result.returncode == 0
+
+            metadata = get_unified_metadata(test_file)
+            assert metadata.get(UnifiedMetadataKey.TITLE) == "FLAC Test"
+            assert metadata.get(UnifiedMetadataKey.ARTISTS) == ["FLAC Artist"]
+            assert metadata.get(UnifiedMetadataKey.ALBUM) == "FLAC Album"
+            assert metadata.get(UnifiedMetadataKey.TRACK_NUMBER) == "3/10"
+            assert metadata.get(UnifiedMetadataKey.DISC_NUMBER) == 1
+            assert metadata.get(UnifiedMetadataKey.DISC_TOTAL) == 2
+            assert metadata.get(UnifiedMetadataKey.BPM) == 140
+            assert metadata.get(UnifiedMetadataKey.LANGUAGE) == "eng"
+            assert metadata.get(UnifiedMetadataKey.COMPOSERS) == ["FLAC Composer"]
+            assert metadata.get(UnifiedMetadataKey.PUBLISHER) == "FLAC Publisher"
+            assert metadata.get(UnifiedMetadataKey.COPYRIGHT) == "© FLAC"
+            assert metadata.get(UnifiedMetadataKey.UNSYNCHRONIZED_LYRICS) == "FLAC lyrics"
+            assert metadata.get(UnifiedMetadataKey.COMMENT) == "FLAC comment"
+            assert metadata.get(UnifiedMetadataKey.ISRC) == "FRXXX1800001"
+
+    def test_cli_write_wav_all_fields(self):
+        with temp_file_with_metadata({}, "wav") as test_file:
+            result = subprocess.run(
+                [
+                    sys.executable,
+                    "-m",
+                    "audiometa",
+                    "write",
+                    str(test_file),
+                    "--title",
+                    "WAV Test",
+                    "--artist",
+                    "WAV Artist",
+                    "--album",
+                    "WAV Album",
+                    "--year",
+                    "2024",
+                    "--genre",
+                    "Rock",
+                    "--rating",
+                    "100",
+                    "--bpm",
+                    "120",
+                    "--language",
+                    "eng",
+                    "--composer",
+                    "WAV Composer",
+                    "--copyright",
+                    "© WAV",
+                    "--comment",
+                    "WAV comment",
+                    "--isrc",
+                    "GBUM71505078",
+                ],
+                capture_output=True,
+                text=True,
+                check=False,
+            )
+            assert result.returncode == 0
+
+            metadata = get_unified_metadata(test_file)
+            assert metadata.get(UnifiedMetadataKey.TITLE) == "WAV Test"
+            assert metadata.get(UnifiedMetadataKey.ARTISTS) == ["WAV Artist"]
+            assert metadata.get(UnifiedMetadataKey.ALBUM) == "WAV Album"
+            assert metadata.get(UnifiedMetadataKey.RELEASE_DATE) == "2024"
+            assert metadata.get(UnifiedMetadataKey.GENRES_NAMES) == ["Rock"]
+            assert metadata.get(UnifiedMetadataKey.RATING) == 100
+            assert metadata.get(UnifiedMetadataKey.BPM) == 120
+            assert metadata.get(UnifiedMetadataKey.LANGUAGE) == "eng"
+            assert metadata.get(UnifiedMetadataKey.COMPOSERS) == ["WAV Composer"]
+            assert metadata.get(UnifiedMetadataKey.COPYRIGHT) == "© WAV"
+            assert metadata.get(UnifiedMetadataKey.COMMENT) == "WAV comment"
+            assert metadata.get(UnifiedMetadataKey.ISRC) == "GBUM71505078"