itunes-export 0.1.0__tar.gz

itunes_export-0.1.0/PKG-INFO

@@ -0,0 +1,77 @@
+Metadata-Version: 2.4
+Name: itunes-export
+Version: 0.1.0
+Summary: Export Apple Music / iTunes playlists to CSV, XML, or JSON — no manual steps
+License: MIT
+Project-URL: Homepage, https://github.com/Gnomecromancer/itunes-export
+Project-URL: Repository, https://github.com/Gnomecromancer/itunes-export
+Project-URL: Issues, https://github.com/Gnomecromancer/itunes-export/issues
+Keywords: apple-music,itunes,playlist,export,csv,music,windows
+Classifier: Development Status :: 4 - Beta
+Classifier: Intended Audience :: End Users/Desktop
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: Microsoft :: Windows
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.8
+Classifier: Programming Language :: Python :: 3.9
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Topic :: Multimedia :: Sound/Audio
+Requires-Python: >=3.8
+Description-Content-Type: text/markdown
+Requires-Dist: pywin32; sys_platform == "win32"
+
+# itunes-export
+
+Export Apple Music / iTunes playlists to CSV, XML, or JSON from the command line — no manual dragging, no XML library hacks. Uses the iTunes COM interface directly.
+
+```
+pip install itunes-export
+```
+
+**Requires Windows with Apple Music or iTunes installed.**
+
+## Usage
+
+```
+itunes-export --list
+itunes-export --playlist "My Favorites"
+itunes-export --playlist "Road Trip" --format xml
+itunes-export --playlist "Road Trip" --format json
+itunes-export --playlist "Road Trip" --output road_trip.csv
+```
+
+## Exported fields
+
+Name, Artist, Album, Album Artist, Composer, Genre, Year, Track Number, Track Count, Disc Number, Disc Count, Duration, Bit Rate, Sample Rate, Rating, Play Count, Date Added, Location, BPM, Comment, Kind
+
+## Formats
+
+- **CSV** (default) — UTF-8 with BOM for Excel compatibility
+- **XML** — structured `<Playlist><Track>` document
+- **JSON** — `{ playlist, exported, count, tracks: [...] }`
+
+## Python API
+
+```python
+from itunes_export import connect, get_user_playlists, find_playlist, export_csv
+
+app = connect()
+playlists = get_user_playlists(app)
+matches = find_playlist(playlists, "Road Trip")
+name, pl = matches[0]
+
+rows = [track_row(pl.Tracks.Item(i)) for i in range(1, pl.Tracks.Count + 1)]
+export_csv(rows, "road_trip.csv")
+```
+
+## Requirements
+
+- Windows
+- Apple Music or iTunes installed
+- Python 3.8+
+
+## License
+
+MIT

itunes_export-0.1.0/README.md

@@ -0,0 +1,53 @@
+# itunes-export
+
+Export Apple Music / iTunes playlists to CSV, XML, or JSON from the command line — no manual dragging, no XML library hacks. Uses the iTunes COM interface directly.
+
+```
+pip install itunes-export
+```
+
+**Requires Windows with Apple Music or iTunes installed.**
+
+## Usage
+
+```
+itunes-export --list
+itunes-export --playlist "My Favorites"
+itunes-export --playlist "Road Trip" --format xml
+itunes-export --playlist "Road Trip" --format json
+itunes-export --playlist "Road Trip" --output road_trip.csv
+```
+
+## Exported fields
+
+Name, Artist, Album, Album Artist, Composer, Genre, Year, Track Number, Track Count, Disc Number, Disc Count, Duration, Bit Rate, Sample Rate, Rating, Play Count, Date Added, Location, BPM, Comment, Kind
+
+## Formats
+
+- **CSV** (default) — UTF-8 with BOM for Excel compatibility
+- **XML** — structured `<Playlist><Track>` document
+- **JSON** — `{ playlist, exported, count, tracks: [...] }`
+
+## Python API
+
+```python
+from itunes_export import connect, get_user_playlists, find_playlist, export_csv
+
+app = connect()
+playlists = get_user_playlists(app)
+matches = find_playlist(playlists, "Road Trip")
+name, pl = matches[0]
+
+rows = [track_row(pl.Tracks.Item(i)) for i in range(1, pl.Tracks.Count + 1)]
+export_csv(rows, "road_trip.csv")
+```
+
+## Requirements
+
+- Windows
+- Apple Music or iTunes installed
+- Python 3.8+
+
+## License
+
+MIT

itunes_export-0.1.0/pyproject.toml

@@ -0,0 +1,39 @@
+[build-system]
+requires = ["setuptools>=68", "wheel"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "itunes-export"
+version = "0.1.0"
+description = "Export Apple Music / iTunes playlists to CSV, XML, or JSON — no manual steps"
+readme = "README.md"
+license = { text = "MIT" }
+requires-python = ">=3.8"
+dependencies = ["pywin32; sys_platform == 'win32'"]
+keywords = [
+    "apple-music", "itunes", "playlist", "export", "csv", "music", "windows"
+]
+classifiers = [
+    "Development Status :: 4 - Beta",
+    "Intended Audience :: End Users/Desktop",
+    "License :: OSI Approved :: MIT License",
+    "Operating System :: Microsoft :: Windows",
+    "Programming Language :: Python :: 3",
+    "Programming Language :: Python :: 3.8",
+    "Programming Language :: Python :: 3.9",
+    "Programming Language :: Python :: 3.10",
+    "Programming Language :: Python :: 3.11",
+    "Programming Language :: Python :: 3.12",
+    "Topic :: Multimedia :: Sound/Audio",
+]
+
+[project.scripts]
+itunes-export = "itunes_export.cli:main"
+
+[project.urls]
+Homepage = "https://github.com/Gnomecromancer/itunes-export"
+Repository = "https://github.com/Gnomecromancer/itunes-export"
+Issues = "https://github.com/Gnomecromancer/itunes-export/issues"
+
+[tool.setuptools.packages.find]
+where = ["src"]

itunes_export-0.1.0/setup.cfg

@@ -0,0 +1,4 @@
+[egg_info]
+tag_build = 
+tag_date = 0
+

itunes_export-0.1.0/src/itunes_export/__init__.py

@@ -0,0 +1,23 @@
+"""Apple Music / iTunes playlist exporter."""
+
+from .core import (
+    connect,
+    get_user_playlists,
+    find_playlist,
+    list_playlists,
+    track_row,
+    export_csv,
+    export_xml,
+    export_json,
+)
+
+__all__ = [
+    "connect",
+    "get_user_playlists",
+    "find_playlist",
+    "list_playlists",
+    "track_row",
+    "export_csv",
+    "export_xml",
+    "export_json",
+]

itunes_export-0.1.0/src/itunes_export/cli.py

@@ -0,0 +1,108 @@
+"""Command-line interface for itunes-export."""
+
+import sys
+import argparse
+from pathlib import Path
+
+from .core import (
+    connect,
+    get_user_playlists,
+    find_playlist,
+    list_playlists,
+    track_row,
+    export_csv,
+    export_xml,
+    export_json,
+)
+
+
+def _collect_tracks(pl, name):
+    """Pull all track rows from a playlist with a progress bar."""
+    try:
+        tracks = pl.Tracks
+        total = tracks.Count
+    except Exception as e:
+        print(f"Error accessing tracks: {e}", file=sys.stderr)
+        sys.exit(1)
+
+    print(f"\nExporting '{name}'  ({total:,} tracks) ...")
+    rows = []
+    for i in range(1, total + 1):
+        rows.append(track_row(tracks.Item(i)))
+        if i % 50 == 0 or i == total:
+            pct = i / total * 100
+            bar = "#" * int(pct // 2) + "-" * (50 - int(pct // 2))
+            print(f"\r  [{bar}] {i:,}/{total:,} ({pct:.0f}%)", end="", flush=True)
+    print()
+    return rows
+
+
+def main():
+    parser = argparse.ArgumentParser(
+        description="Export Apple Music / iTunes playlists to CSV, XML, or JSON",
+        formatter_class=argparse.RawDescriptionHelpFormatter,
+        epilog="""
+Examples:
+  itunes-export --list
+  itunes-export --playlist "My Favorites"
+  itunes-export --playlist "Road Trip" --format xml
+  itunes-export --playlist "Road Trip" --format json
+  itunes-export --playlist "Road Trip" --output road_trip.csv
+        """,
+    )
+    parser.add_argument("--list", "-l", action="store_true",
+                        help="List all playlists with track counts")
+    parser.add_argument("--playlist", "-p", metavar="NAME",
+                        help="Playlist to export (partial name match ok)")
+    parser.add_argument("--format", "-f", choices=["csv", "xml", "json"], default="csv",
+                        help="Output format (default: csv)")
+    parser.add_argument("--output", "-o", metavar="FILE",
+                        help="Output path (default: <playlist name>.<format>)")
+
+    args = parser.parse_args()
+    if not args.list and not args.playlist:
+        parser.print_help()
+        sys.exit(0)
+
+    print("Connecting to Apple Music / iTunes ...")
+    try:
+        app = connect()
+    except RuntimeError as e:
+        print(f"Error: {e}", file=sys.stderr)
+        sys.exit(1)
+
+    playlists = get_user_playlists(app)
+
+    if args.list:
+        list_playlists(playlists)
+
+    if args.playlist:
+        matches = find_playlist(playlists, args.playlist)
+        if not matches:
+            print(f"Error: Playlist '{args.playlist}' not found.", file=sys.stderr)
+            print("Use --list to see available playlists.", file=sys.stderr)
+            sys.exit(1)
+        if len(matches) > 1:
+            print(f"Multiple playlists match '{args.playlist}':", file=sys.stderr)
+            for n, _ in matches:
+                print(f"  - {n}", file=sys.stderr)
+            print("Please be more specific.", file=sys.stderr)
+            sys.exit(1)
+
+        name, pl = matches[0]
+        rows = _collect_tracks(pl, name)
+
+        if args.output is None:
+            safe_name = "".join(c for c in name if c.isalnum() or c in " _-").strip()
+            out_path = Path(f"{safe_name}.{args.format}")
+        else:
+            out_path = Path(args.output)
+
+        if args.format == "csv":
+            export_csv(rows, out_path)
+        elif args.format == "xml":
+            export_xml(rows, name, out_path)
+        else:
+            export_json(rows, name, out_path)
+
+        print(f"Done. {len(rows):,} tracks → {out_path.resolve()}")

itunes_export-0.1.0/src/itunes_export/core.py

@@ -0,0 +1,148 @@
+"""Core logic: COM connection, track extraction, export formats."""
+
+import csv
+import json
+import xml.etree.ElementTree as ET
+from datetime import datetime
+from pathlib import Path
+
+
+TRACK_FIELDS = [
+    "Name", "Artist", "Album", "Album Artist", "Composer",
+    "Genre", "Year", "Track Number", "Track Count",
+    "Disc Number", "Disc Count", "Duration",
+    "Bit Rate", "Sample Rate", "Rating", "Play Count",
+    "Date Added", "Location", "BPM", "Comment", "Kind",
+]
+
+
+def connect():
+    """Connect to iTunes/Apple Music via COM and return the application object."""
+    try:
+        import win32com.client  # type: ignore[import-untyped]
+        return win32com.client.Dispatch("iTunes.Application")
+    except ImportError as e:
+        raise RuntimeError(
+            "pywin32 is required on Windows.  Run:  pip install pywin32"
+        ) from e
+    except Exception as e:
+        raise RuntimeError(
+            f"Could not connect to iTunes/Apple Music COM: {e}\n"
+            "Make sure Apple Music or iTunes is installed."
+        ) from e
+
+
+def get_user_playlists(app):
+    """Return list of (name, playlist_com_object) for all user playlists."""
+    results = []
+    for source in app.Sources:
+        if source.Kind == 1:  # kITSourceLibrary
+            for pl in source.Playlists:
+                results.append((pl.Name, pl))
+    return results
+
+
+def _safe(obj, attr):
+    try:
+        v = getattr(obj, attr)
+        return v if v is not None else ""
+    except Exception:
+        return ""
+
+
+def _format_duration(seconds):
+    if not seconds:
+        return ""
+    s = int(seconds)
+    return f"{s // 60}:{s % 60:02d}"
+
+
+def track_row(track):
+    """Extract a dict of metadata fields from a COM track object."""
+    try:
+        raw_date = track.DateAdded
+        date_added = raw_date.strftime("%Y-%m-%d %H:%M:%S") if raw_date else ""
+    except Exception:
+        date_added = ""
+
+    return {
+        "Name":         _safe(track, "Name"),
+        "Artist":       _safe(track, "Artist"),
+        "Album":        _safe(track, "Album"),
+        "Album Artist": _safe(track, "AlbumArtist"),
+        "Composer":     _safe(track, "Composer"),
+        "Genre":        _safe(track, "Genre"),
+        "Year":         _safe(track, "Year"),
+        "Track Number": _safe(track, "TrackNumber"),
+        "Track Count":  _safe(track, "TrackCount"),
+        "Disc Number":  _safe(track, "DiscNumber"),
+        "Disc Count":   _safe(track, "DiscCount"),
+        "Duration":     _format_duration(_safe(track, "Duration")),
+        "Bit Rate":     _safe(track, "BitRate"),
+        "Sample Rate":  _safe(track, "SampleRate"),
+        "Rating":       _safe(track, "Rating"),
+        "Play Count":   _safe(track, "PlayedCount"),
+        "Date Added":   date_added,
+        "Location":     _safe(track, "Location"),
+        "BPM":          _safe(track, "BPM"),
+        "Comment":      _safe(track, "Comment"),
+        "Kind":         _safe(track, "KindAsString"),
+    }
+
+
+def list_playlists(playlists):
+    """Print playlist names and track counts to stdout."""
+    print(f"\nAvailable playlists ({len(playlists)}):")
+    for i, (name, pl) in enumerate(playlists, 1):
+        try:
+            count = pl.Tracks.Count
+        except Exception:
+            count = "?"
+        if isinstance(count, int):
+            print(f"  {i:3}. {name}  ({count:,} tracks)")
+        else:
+            print(f"  {i:3}. {name}  ({count} tracks)")
+
+
+def find_playlist(playlists, name):
+    """Return matching (name, playlist) pairs; exact match first, then partial."""
+    exact = [(n, pl) for n, pl in playlists if n.lower() == name.lower()]
+    if exact:
+        return exact
+    return [(n, pl) for n, pl in playlists if name.lower() in n.lower()]
+
+
+def export_csv(rows, path):
+    """Write track rows to a UTF-8 CSV file."""
+    with open(path, "w", newline="", encoding="utf-8-sig") as f:
+        writer = csv.DictWriter(f, fieldnames=TRACK_FIELDS)
+        writer.writeheader()
+        writer.writerows(rows)
+
+
+def export_xml(rows, playlist_name, path):
+    """Write track rows to a UTF-8 XML file."""
+    root = ET.Element("Playlist")
+    root.set("name", playlist_name)
+    root.set("exported", datetime.now().isoformat())
+    root.set("count", str(len(rows)))
+    for row in rows:
+        el = ET.SubElement(root, "Track")
+        for field, value in row.items():
+            child = ET.SubElement(el, field.replace(" ", ""))
+            child.text = str(value)
+    tree = ET.ElementTree(root)
+    ET.indent(tree, space="  ")
+    tree.write(path, encoding="utf-8", xml_declaration=True)
+
+
+def export_json(rows, playlist_name, path):
+    """Write track rows to a UTF-8 JSON file."""
+    payload = {
+        "playlist": playlist_name,
+        "exported": datetime.now().isoformat(),
+        "count": len(rows),
+        "tracks": rows,
+    }
+    with open(path, "w", encoding="utf-8") as f:
+        json.dump(payload, f, indent=2, ensure_ascii=False)

itunes_export-0.1.0/src/itunes_export.egg-info/PKG-INFO

@@ -0,0 +1,77 @@
+Metadata-Version: 2.4
+Name: itunes-export
+Version: 0.1.0
+Summary: Export Apple Music / iTunes playlists to CSV, XML, or JSON — no manual steps
+License: MIT
+Project-URL: Homepage, https://github.com/Gnomecromancer/itunes-export
+Project-URL: Repository, https://github.com/Gnomecromancer/itunes-export
+Project-URL: Issues, https://github.com/Gnomecromancer/itunes-export/issues
+Keywords: apple-music,itunes,playlist,export,csv,music,windows
+Classifier: Development Status :: 4 - Beta
+Classifier: Intended Audience :: End Users/Desktop
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: Microsoft :: Windows
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.8
+Classifier: Programming Language :: Python :: 3.9
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Topic :: Multimedia :: Sound/Audio
+Requires-Python: >=3.8
+Description-Content-Type: text/markdown
+Requires-Dist: pywin32; sys_platform == "win32"
+
+# itunes-export
+
+Export Apple Music / iTunes playlists to CSV, XML, or JSON from the command line — no manual dragging, no XML library hacks. Uses the iTunes COM interface directly.
+
+```
+pip install itunes-export
+```
+
+**Requires Windows with Apple Music or iTunes installed.**
+
+## Usage
+
+```
+itunes-export --list
+itunes-export --playlist "My Favorites"
+itunes-export --playlist "Road Trip" --format xml
+itunes-export --playlist "Road Trip" --format json
+itunes-export --playlist "Road Trip" --output road_trip.csv
+```
+
+## Exported fields
+
+Name, Artist, Album, Album Artist, Composer, Genre, Year, Track Number, Track Count, Disc Number, Disc Count, Duration, Bit Rate, Sample Rate, Rating, Play Count, Date Added, Location, BPM, Comment, Kind
+
+## Formats
+
+- **CSV** (default) — UTF-8 with BOM for Excel compatibility
+- **XML** — structured `<Playlist><Track>` document
+- **JSON** — `{ playlist, exported, count, tracks: [...] }`
+
+## Python API
+
+```python
+from itunes_export import connect, get_user_playlists, find_playlist, export_csv
+
+app = connect()
+playlists = get_user_playlists(app)
+matches = find_playlist(playlists, "Road Trip")
+name, pl = matches[0]
+
+rows = [track_row(pl.Tracks.Item(i)) for i in range(1, pl.Tracks.Count + 1)]
+export_csv(rows, "road_trip.csv")
+```
+
+## Requirements
+
+- Windows
+- Apple Music or iTunes installed
+- Python 3.8+
+
+## License
+
+MIT

itunes_export-0.1.0/src/itunes_export.egg-info/SOURCES.txt

@@ -0,0 +1,12 @@
+README.md
+pyproject.toml
+src/itunes_export/__init__.py
+src/itunes_export/cli.py
+src/itunes_export/core.py
+src/itunes_export.egg-info/PKG-INFO
+src/itunes_export.egg-info/SOURCES.txt
+src/itunes_export.egg-info/dependency_links.txt
+src/itunes_export.egg-info/entry_points.txt
+src/itunes_export.egg-info/requires.txt
+src/itunes_export.egg-info/top_level.txt
+tests/test_core.py

itunes_export-0.1.0/src/itunes_export.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

itunes_export-0.1.0/src/itunes_export.egg-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+itunes-export = itunes_export.cli:main

itunes_export-0.1.0/src/itunes_export.egg-info/requires.txt

@@ -0,0 +1,3 @@
+
+[:sys_platform == "win32"]
+pywin32

itunes_export-0.1.0/src/itunes_export.egg-info/top_level.txt

@@ -0,0 +1 @@
+itunes_export

itunes_export-0.1.0/tests/test_core.py

@@ -0,0 +1,305 @@
+"""Tests for itunes_export core logic — uses mocked COM objects."""
+
+import json
+import tempfile
+from pathlib import Path
+from unittest.mock import MagicMock, patch, PropertyMock
+import pytest
+
+from itunes_export.core import (
+    _safe,
+    _format_duration,
+    track_row,
+    find_playlist,
+    list_playlists,
+    export_csv,
+    export_xml,
+    export_json,
+    TRACK_FIELDS,
+)
+
+
+# ---------------------------------------------------------------------------
+# Helpers
+# ---------------------------------------------------------------------------
+
+def make_track(name="Song", artist="Artist", album="Album", **kwargs):
+    """Build a mock COM track object."""
+    t = MagicMock()
+    t.Name = name
+    t.Artist = artist
+    t.Album = album
+    t.AlbumArtist = kwargs.get("album_artist", "")
+    t.Composer = kwargs.get("composer", "")
+    t.Genre = kwargs.get("genre", "Rock")
+    t.Year = kwargs.get("year", 2020)
+    t.TrackNumber = kwargs.get("track_number", 1)
+    t.TrackCount = kwargs.get("track_count", 10)
+    t.DiscNumber = kwargs.get("disc_number", 1)
+    t.DiscCount = kwargs.get("disc_count", 1)
+    t.Duration = kwargs.get("duration", 180)
+    t.BitRate = kwargs.get("bit_rate", 256)
+    t.SampleRate = kwargs.get("sample_rate", 44100)
+    t.Rating = kwargs.get("rating", 80)
+    t.PlayedCount = kwargs.get("play_count", 5)
+    t.DateAdded = kwargs.get("date_added", None)
+    t.Location = kwargs.get("location", "C:\\Music\\song.mp3")
+    t.BPM = kwargs.get("bpm", 120)
+    t.Comment = kwargs.get("comment", "")
+    t.KindAsString = kwargs.get("kind", "MPEG audio file")
+    return t
+
+
+def make_playlist(name, tracks):
+    """Build a mock COM playlist with a list of track objects."""
+    pl = MagicMock()
+    pl.Name = name
+    pl.Tracks.Count = len(tracks)
+    pl.Tracks.Item = lambda i: tracks[i - 1]
+    return pl
+
+
+# ---------------------------------------------------------------------------
+# _safe
+# ---------------------------------------------------------------------------
+
+class TestSafe:
+    def test_returns_attribute(self):
+        obj = MagicMock()
+        obj.Foo = "bar"
+        assert _safe(obj, "Foo") == "bar"
+
+    def test_returns_empty_on_exception(self):
+        obj = MagicMock()
+        type(obj).Broken = PropertyMock(side_effect=Exception("oops"))
+        assert _safe(obj, "Broken") == ""
+
+    def test_returns_empty_for_none(self):
+        obj = MagicMock()
+        obj.Val = None
+        assert _safe(obj, "Val") == ""
+
+
+# ---------------------------------------------------------------------------
+# _format_duration
+# ---------------------------------------------------------------------------
+
+class TestFormatDuration:
+    def test_zero(self):
+        assert _format_duration(0) == ""
+
+    def test_empty(self):
+        assert _format_duration("") == ""
+
+    def test_seconds(self):
+        assert _format_duration(90) == "1:30"
+
+    def test_exact_minute(self):
+        assert _format_duration(60) == "1:00"
+
+    def test_long(self):
+        assert _format_duration(3661) == "61:01"
+
+    def test_pads_seconds(self):
+        assert _format_duration(65) == "1:05"
+
+
+# ---------------------------------------------------------------------------
+# track_row
+# ---------------------------------------------------------------------------
+
+class TestTrackRow:
+    def test_basic_fields(self):
+        t = make_track(name="Hello", artist="World", genre="Pop")
+        row = track_row(t)
+        assert row["Name"] == "Hello"
+        assert row["Artist"] == "World"
+        assert row["Genre"] == "Pop"
+
+    def test_all_fields_present(self):
+        row = track_row(make_track())
+        for field in TRACK_FIELDS:
+            assert field in row
+
+    def test_duration_formatted(self):
+        t = make_track(duration=125)
+        row = track_row(t)
+        assert row["Duration"] == "2:05"
+
+    def test_date_added_none(self):
+        t = make_track(date_added=None)
+        row = track_row(t)
+        assert row["Date Added"] == ""
+
+    def test_date_added_formatted(self):
+        from datetime import datetime
+        t = make_track(date_added=datetime(2023, 6, 15, 10, 30, 0))
+        row = track_row(t)
+        assert row["Date Added"] == "2023-06-15 10:30:00"
+
+
+# ---------------------------------------------------------------------------
+# find_playlist
+# ---------------------------------------------------------------------------
+
+class TestFindPlaylist:
+    def setup_method(self):
+        self.pl_a = MagicMock()
+        self.pl_b = MagicMock()
+        self.pl_c = MagicMock()
+        self.playlists = [
+            ("My Favorites", self.pl_a),
+            ("Road Trip", self.pl_b),
+            ("Jazz Classics", self.pl_c),
+        ]
+
+    def test_exact_match(self):
+        result = find_playlist(self.playlists, "Road Trip")
+        assert len(result) == 1
+        assert result[0][0] == "Road Trip"
+
+    def test_case_insensitive_exact(self):
+        result = find_playlist(self.playlists, "road trip")
+        assert len(result) == 1
+
+    def test_partial_match(self):
+        result = find_playlist(self.playlists, "Jazz")
+        assert len(result) == 1
+        assert result[0][0] == "Jazz Classics"
+
+    def test_no_match(self):
+        result = find_playlist(self.playlists, "Nonexistent")
+        assert result == []
+
+    def test_multiple_partial_matches(self):
+        playlists = [("Rock Hits", MagicMock()), ("Rock Classics", MagicMock())]
+        result = find_playlist(playlists, "Rock")
+        assert len(result) == 2
+
+    def test_exact_wins_over_partial(self):
+        playlists = [("Jazz", MagicMock()), ("Jazz Classics", MagicMock())]
+        result = find_playlist(playlists, "Jazz")
+        assert len(result) == 1
+        assert result[0][0] == "Jazz"
+
+
+# ---------------------------------------------------------------------------
+# list_playlists
+# ---------------------------------------------------------------------------
+
+class TestListPlaylists:
+    def test_prints_without_error(self, capsys):
+        pl = MagicMock()
+        pl.Tracks.Count = 42
+        list_playlists([("My Mix", pl)])
+        out = capsys.readouterr().out
+        assert "My Mix" in out
+        assert "42" in out
+
+    def test_handles_count_exception(self, capsys):
+        pl = MagicMock()
+        type(pl.Tracks).Count = PropertyMock(side_effect=Exception)
+        list_playlists([("Broken", pl)])
+        out = capsys.readouterr().out
+        assert "Broken" in out
+
+
+# ---------------------------------------------------------------------------
+# export_csv
+# ---------------------------------------------------------------------------
+
+class TestExportCsv:
+    def test_creates_file(self):
+        rows = [track_row(make_track(name="A")), track_row(make_track(name="B"))]
+        with tempfile.NamedTemporaryFile(suffix=".csv", delete=False) as f:
+            path = Path(f.name)
+        export_csv(rows, path)
+        assert path.exists()
+        content = path.read_text(encoding="utf-8-sig")
+        assert "Name" in content
+        assert "Artist" in content
+
+    def test_row_count(self):
+        rows = [track_row(make_track()) for _ in range(5)]
+        with tempfile.NamedTemporaryFile(suffix=".csv", delete=False) as f:
+            path = Path(f.name)
+        export_csv(rows, path)
+        lines = path.read_text(encoding="utf-8-sig").strip().splitlines()
+        assert len(lines) == 6  # header + 5 rows
+
+    def test_track_name_in_output(self):
+        rows = [track_row(make_track(name="Stairway To Heaven"))]
+        with tempfile.NamedTemporaryFile(suffix=".csv", delete=False) as f:
+            path = Path(f.name)
+        export_csv(rows, path)
+        assert "Stairway To Heaven" in path.read_text(encoding="utf-8-sig")
+
+
+# ---------------------------------------------------------------------------
+# export_xml
+# ---------------------------------------------------------------------------
+
+class TestExportXml:
+    def test_creates_valid_xml(self):
+        rows = [track_row(make_track(name="TestSong"))]
+        with tempfile.NamedTemporaryFile(suffix=".xml", delete=False) as f:
+            path = Path(f.name)
+        export_xml(rows, "Test Playlist", path)
+        import xml.etree.ElementTree as ET
+        tree = ET.parse(path)
+        root = tree.getroot()
+        assert root.tag == "Playlist"
+        assert root.get("name") == "Test Playlist"
+        assert root.get("count") == "1"
+
+    def test_track_name_present(self):
+        rows = [track_row(make_track(name="MyTrack"))]
+        with tempfile.NamedTemporaryFile(suffix=".xml", delete=False) as f:
+            path = Path(f.name)
+        export_xml(rows, "PL", path)
+        content = path.read_text(encoding="utf-8")
+        assert "MyTrack" in content
+
+    def test_multiple_tracks(self):
+        rows = [track_row(make_track()) for _ in range(3)]
+        with tempfile.NamedTemporaryFile(suffix=".xml", delete=False) as f:
+            path = Path(f.name)
+        export_xml(rows, "Multi", path)
+        import xml.etree.ElementTree as ET
+        root = ET.parse(path).getroot()
+        assert len(list(root)) == 3
+
+
+# ---------------------------------------------------------------------------
+# export_json
+# ---------------------------------------------------------------------------
+
+class TestExportJson:
+    def test_creates_valid_json(self):
+        rows = [track_row(make_track(name="JsonSong"))]
+        with tempfile.NamedTemporaryFile(suffix=".json", delete=False) as f:
+            path = Path(f.name)
+        export_json(rows, "JSON Playlist", path)
+        data = json.loads(path.read_text(encoding="utf-8"))
+        assert data["playlist"] == "JSON Playlist"
+        assert data["count"] == 1
+        assert len(data["tracks"]) == 1
+        assert data["tracks"][0]["Name"] == "JsonSong"
+
+    def test_multiple_tracks(self):
+        rows = [track_row(make_track(name=f"Track {i}")) for i in range(5)]
+        with tempfile.NamedTemporaryFile(suffix=".json", delete=False) as f:
+            path = Path(f.name)
+        export_json(rows, "Five", path)
+        data = json.loads(path.read_text(encoding="utf-8"))
+        assert data["count"] == 5
+        assert len(data["tracks"]) == 5
+
+    def test_has_exported_timestamp(self):
+        rows = [track_row(make_track())]
+        with tempfile.NamedTemporaryFile(suffix=".json", delete=False) as f:
+            path = Path(f.name)
+        export_json(rows, "PL", path)
+        data = json.loads(path.read_text(encoding="utf-8"))
+        assert "exported" in data
+        assert len(data["exported"]) > 0