added --user feature

Author: donmerendolo

.github/workflows/build-release.yml

@@ -6,6 +6,10 @@ on:
     tags: [ 'v*' ]
   workflow_dispatch:
 
+permissions:
+  actions: none
+  contents: write
+
 jobs:
   build:
     runs-on: ${{ matrix.os }}
@@ -40,7 +44,9 @@ jobs:
       run: uv sync
 
     - name: Build executable
-      run: uvx pyinstaller --onefile --name ${{ matrix.binary_name }} exportify-cli.py
+      run: |
+        uv add pyinstaller
+        uv run pyinstaller --onefile --name ${{ matrix.binary_name }} exportify-cli.py
     
     - name: Upload artifact
       uses: actions/upload-artifact@v5
@@ -68,4 +74,4 @@ jobs:
           exportify-cli-macos-intel/exportify-cli-macos-intel
           exportify-cli-macos-arm64/exportify-cli-macos-arm64
       env:
-        GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
+        GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}

README.md

@@ -6,7 +6,7 @@ Export Spotify playlists to CSV or JSON directly from the terminal, inspired by
 This tool can export all saved playlists, including liked songs.
 
 ## Installation:
-**If you use Windows, you can download the [binary](https://github.com/donmerendolo/exportify-cli/releases/latest/download/exportify-cli.exe) and skip steps 1 and 2. It's recommended to place it in a dedicated folder for better organization.**
+**You can also download a binary from the [releases page](https://github.com/donmerendolo/exportify-cli/releases/latest) and skip steps 1 and 2. It's recommended to place it in a dedicated folder since it will create .cache, a config file and playlists folders.**
 1. **Clone this repository:**
 ```bash
 git clone https://github.com/donmerendolo/exportify-cli.git
@@ -34,23 +34,26 @@ Now after creating the app, press the Settings button on the upper right corner.
 Copy the Client ID, Client Secret and Redirect URI and paste them below.
 ```
 
-After running `python exportify-cli.py` (or [`exportify-cli.exe`](https://github.com/donmerendolo/exportify-cli/releases/latest/download/exportify-cli.exe) if you use the Windows binary) the first time, it should keep you authenticated so you don't have to log in each time.
+After running `python exportify-cli.py` (or [one of the binaries](https://github.com/donmerendolo/exportify-cli/releases/latest)) the first time, it should keep you authenticated so you don't have to log in each time.
 
 If you wish to log out, simply remove the `.cache` file (you may also have to remove access to `exportify-cli` in https://www.spotify.com/us/account/apps/).
 
 ---
 
 ## Usage:
 ```
-Usage: exportify-cli.py (-a | -p NAME|ID|URL|URI [-p ...] | -l) [OPTIONS]
+Usage: exportify-cli.py (-a | -p NAME|ID|URL|URI [-p ...] | -u ID|URL|URI |
+-l) [OPTIONS]
 
   Export Spotify playlists to CSV or JSON.
 
 Options:
     -a, --all                     Export all playlists
     -p, --playlist NAME|ID|URL|URI
-                                  Spotify playlist name, ID, URL, or URI;
-                                  repeatable.
+                                  Export a Spotify playlist given name, ID,
+                                  URL, or URI; repeatable.
+    -u, --user ID|URL|URI         Export all public playlists of a Spotify
+                                  user given ID, URL, or URI; repeatable.
     -l, --list                    List available playlists.
     -c, --config PATH             Path to configuration file (default is
                                   ./config.cfg next to this script).
@@ -74,7 +77,9 @@ Options:
 
 - You can also export a playlist that's not saved in your library by using its ID, URL, or URI.
 
-- A single command can export multiple playlists by using the `-p` option multiple times.
+- A single command can export multiple playlists by using the `-p` option multiple times. Same applies for the `-u` option.
+
+- You can export all ***public*** playlists of any user by using the `-u` option with their user ID, URL, or URI. It won't save Liked Songs from that user, as it's private.
 
 - The default fields are: `Position`, `Track URI`, `Track Name`, `Album Name`, `Artist Name(s)`, `Release Date`, `Duration_ms`, `Popularity`, `Added By`, `Added At`, `Record Label`. With flags, `Album URI(s)`, `Artist URI(s)`, `Track ISRC` and `Album UPC` can be included too. If you want any other field to be added, feel free to open an issue or PR.
 
@@ -97,6 +102,9 @@ exportify-cli.exe -f json -f csv -p https://open.spotify.com/playlist/2VqAIceMCz
 
 # Export playlists "Instrumental" and "COCHE" to CSV without progress bar, sorted by Popularity
 python exportify-cli.py -p instr -p COCHE -f csv --no-bar --sort-key "popularity"
+
+# Export all public playlists of user with ID "spotifyuser123" and user with URL "https://open.spotify.com/user/anotheruser456"
+python exportify-cli.py -u spotifyuser123 -u https://open.spotify.com/user/anotheruser456
 ```
 
 ---
@@ -105,4 +113,4 @@ python exportify-cli.py -p instr -p COCHE -f csv --no-bar --sort-key "popularity
 I used [PyInstaller](https://pyinstaller.readthedocs.io/en/stable/) to build the windows binary with this command:
 ```bash
 pyinstaller --onefile .\exportify-cli.py
-```
+```

exportify-cli.py

@@ -11,6 +11,7 @@
 import click
 import spotipy
 from click_option_group import OptionGroup, optgroup
+from pathvalidate import sanitize_filename
 from spotipy.oauth2 import SpotifyOAuth
 from tabulate import tabulate
 from tqdm.auto import tqdm
@@ -153,33 +154,24 @@ def init_spotify_client(cfg: configparser.ConfigParser) -> spotipy.Spotify:
     return spotipy.Spotify(auth_manager=auth, retries=10)
 
 
-def sanitize_filename(name: str) -> str:
-    """Convert a playlist name into a safe filename."""
-    safe = "".join(c if c.isalnum() or c in (" ", "_", "-") else "_" for c in name)
-    return f"{safe.strip().replace(' ', '_').lower()}"
-
-
-def write_file(file_path: Path, data: list[dict], file_formats) -> None:
+def write_file(
+    file_path: Path, headers: list[str], data: list[dict], file_formats
+) -> None:
     """Write list of dicts to file."""
-    if not data:
-        logger.warning("No data to write; skipping file.")
-        return
-
     if "csv" in file_formats:
-        headers = list(data[0].keys())
-        with file_path.with_suffix(".csv").open(
-            "w", newline="", encoding="utf-8"
-        ) as csvfile:
+        csv_path = Path(str(file_path) + ".csv")
+        with csv_path.open("w", newline="", encoding="utf-8") as csvfile:
             writer = csv.DictWriter(csvfile, fieldnames=headers)
             writer.writeheader()
             for row in data:
                 writer.writerow(row)
-        logger.info(f"Exported to {file_path}.csv")
+        logger.info(f"Exported to {csv_path}")
 
     if "json" in file_formats:
-        with file_path.with_suffix(".json").open("w", encoding="utf-8") as jsonfile:
+        json_path = Path(str(file_path) + ".json")
+        with json_path.open("w", encoding="utf-8") as jsonfile:
             json.dump(data, jsonfile, ensure_ascii=False, indent=4)
-        logger.info(f"Exported to {file_path}.json")
+        logger.info(f"Exported to {json_path}")
 
 
 class SpotifyExporter:
@@ -347,7 +339,7 @@ def export_playlist(self, playlist: dict, output_dir: Path) -> None:
         """Export a single playlist to CSV file."""
         name, pid = playlist["name"], playlist["id"]
         output_dir.mkdir(parents=True, exist_ok=True)
-        filepath = output_dir / sanitize_filename(name)
+        filepath = output_dir / sanitize_filename(f"{name} [{pid}]")
 
         # Format description for progress bar
         desc = (
@@ -422,6 +414,23 @@ def export_playlist(self, playlist: dict, output_dir: Path) -> None:
 
         # Build export data
         export_data = []
+        headers = [
+            "Position",
+            "Track URI",
+            "Artist URI(s)",
+            "Album URI",
+            "Track Name",
+            "Album Name",
+            "Artist Name(s)",
+            "Release Date",
+            "Duration_ms",
+            "Popularity",
+            "Added By",
+            "Added At",
+            "Record Label",
+            "Track ISRC",
+            "Album UPC",
+        ]
         for i, item in enumerate(items, start=1):
             track = item.get("track") or {}
             album = albums.get(track.get("album", {}).get("id"), {})
@@ -430,23 +439,28 @@ def export_playlist(self, playlist: dict, output_dir: Path) -> None:
                 a.get("uri") for a in track.get("artists", []) if a.get("uri")
             ]
 
-            record = {
-                "Position": i,
-                "Track URI": track.get("uri"),
-                "Artist URI(s)": artist_uris,
-                "Album URI": album.get("uri"),
-                "Track Name": track.get("name"),
-                "Album Name": album.get("name"),
-                "Artist Name(s)": artists,
-                "Release Date": album.get("release_date") or track.get("release_date"),
-                "Duration_ms": track.get("duration_ms"),
-                "Popularity": track.get("popularity"),
-                "Added By": item.get("added_by", {}).get("id"),
-                "Added At": item.get("added_at"),
-                "Record Label": album.get("label"),
-                "Track ISRC": track.get("external_ids", {}).get("isrc"),
-                "Album UPC": album.get("external_ids", {}).get("upc"),
-            }
+            record = dict(
+                zip(
+                    headers,
+                    [
+                        i,
+                        track.get("uri"),
+                        artist_uris,
+                        album.get("uri"),
+                        track.get("name"),
+                        album.get("name"),
+                        artists,
+                        album.get("release_date") or track.get("release_date"),
+                        track.get("duration_ms"),
+                        track.get("popularity"),
+                        item.get("added_by", {}).get("id"),
+                        item.get("added_at"),
+                        album.get("label"),
+                        track.get("external_ids", {}).get("isrc"),
+                        album.get("external_ids", {}).get("upc"),
+                    ],
+                )
+            )
 
             export_data.append(record)
 
@@ -457,15 +471,19 @@ def export_playlist(self, playlist: dict, output_dir: Path) -> None:
             export_data.reverse()
 
         if not self.include_uris:
+            headers.pop(headers.index("Artist URI(s)"))
+            headers.pop(headers.index("Album URI"))
             for record in export_data:
                 record.pop("Artist URI(s)", None)
                 record.pop("Album URI", None)
         if not self.external_ids:
+            headers.pop(headers.index("Track ISRC"))
+            headers.pop(headers.index("Album UPC"))
             for record in export_data:
                 record.pop("Track ISRC", None)
                 record.pop("Album UPC", None)
 
-        write_file(filepath, export_data, self.file_formats)
+        write_file(filepath, headers, export_data, self.file_formats)
         self.exported_playlists += 1
         self.exported_tracks += len(export_data)
         for ext in self.file_formats:
@@ -479,7 +497,7 @@ class CustomCommand(click.Command):
     def format_usage(self, ctx, formatter) -> None:
         # Override the usage display
         formatter.write_text(
-            "Usage: exportify-cli.py (-a | -p NAME|ID|URL|URI [-p ...] | -l) [OPTIONS]\n",
+            "Usage: exportify-cli.py (-a | -p NAME|ID|URL|URI [-p ...] | -u ID|URL|URI | -l) [OPTIONS]\n",
         )
 
 
@@ -492,7 +510,15 @@ def format_usage(self, ctx, formatter) -> None:
     "playlist",
     multiple=True,
     metavar="NAME|ID|URL|URI",
-    help="Spotify playlist name, ID, URL, or URI; repeatable.",
+    help="Export a Spotify playlist given name, ID, URL, or URI; repeatable.",
+)
+@optgroup.option(
+    "-u",
+    "--user",
+    "user",
+    multiple=True,
+    metavar="ID|URL|URI",
+    help="Export all public playlists of a Spotify user given ID, URL, or URI; repeatable.",
 )
 @optgroup.option(
     "-l",
@@ -562,7 +588,7 @@ def format_usage(self, ctx, formatter) -> None:
 )
 @click.help_option("-h", "--help")
 @click.version_option(
-    "0.3",
+    "0.4",
     "-v",
     "--version",
     prog_name="exportify-cli",
@@ -571,6 +597,7 @@ def format_usage(self, ctx, formatter) -> None:
 def main(
     export_all: bool,
     playlist: tuple[str, ...],
+    user: tuple[str, ...],
     list_only: bool,
     config: None | str,
     output_param: str,
@@ -582,8 +609,8 @@ def main(
     reverse_order: bool,
 ) -> None:
     """Export Spotify playlists to CSV or JSON."""
-    # If no --all, --playlist or --list options are given, show help
-    if not export_all and not playlist and not list_only:
+    # If no --all, --playlist, --user or --list options are given, show help
+    if not (export_all or playlist or user or list_only):
         click.echo(main.get_help(ctx=click.get_current_context()))
         sys.exit(1)
 
@@ -643,12 +670,12 @@ def main(
     # Find the actual key that matches case-insensitively
     actual_key = None
     found = False
+
+    def normalize_key(s: str) -> str:
+        return re.sub(r"[\s_()]", "", s.lower())
+
     for key in keys:
-        if key.lower().replace(" ", "").replace("_", "").replace("(", "").replace(
-            ")", ""
-        ) == sort_key.lower().replace(" ", "").replace("_", "").replace(
-            "(", ""
-        ).replace(")", ""):
+        if normalize_key(key) == normalize_key(sort_key):
             actual_key = key
             found = True
             break
@@ -699,6 +726,35 @@ def main(
         )
         sys.exit(0)
 
+    users_targets = []
+    if user:
+        user_ids = []
+        for u in user:
+            uid = re.sub(r"^.*users?\/([a-zA-Z0-9]+).*$", r"\1", u)
+            uid = uid.replace("spotify:user:", "")
+            user_ids.append(uid)
+
+        for uid in user_ids:
+            try:
+                items = exporter._fetch_all_items(
+                    client.user_playlists,
+                    "items",
+                    uid,
+                    desc=f"Playlists of {uid}",
+                    show_bar=False,
+                )
+                user_data = client.user(uid)
+
+                users_targets.append(
+                    {
+                        "name": user_data.get("display_name") or uid,
+                        "uid": uid,
+                        "items": items,
+                    }
+                )
+            except spotipy.SpotifyException as e:
+                logger.warning(f"Failed to fetch playlists for user {uid}: {e}")
+
     # Determine targets
     targets = []
     if export_all:
@@ -735,17 +791,29 @@ def main(
                 except spotipy.SpotifyException as e:
                     logger.warning(f"Failed to fetch playlist {term}: {e}")
 
+    if users_targets:
+        for ut in users_targets:
+            ut["targets"] = []
+            for t in ut["items"]:
+                if t["uri"]:
+                    ut["targets"].append(t)
+
     # Deduplicate
     targets = list({p["id"]: p for p in targets}.values())
 
-    if not targets:
+    if not (targets or users_targets):
         click.echo("No matching playlists found.")
         sys.exit(1)
 
     out_dir = Path(output)
     for pl in targets:
         exporter.export_playlist(pl, out_dir)
 
+    for ut in users_targets:
+        user_out_dir = out_dir / Path(sanitize_filename(f"{ut['name']} [{ut['uid']}]"))
+        for pl in ut["targets"]:
+            exporter.export_playlist(pl, user_out_dir)
+
     if exporter.exported_playlists > 1:
         click.echo(
             f"Successfully exported {exporter.exported_tracks} tracks "

pyproject.toml

@@ -7,6 +7,7 @@ requires-python = ">=3.11"
 dependencies = [
     "click>=8.1.8",
     "click-option-group>=0.5.7",
+    "pathvalidate>=3.3.1",
     "pyinstaller>=6.13.0",
     "requests>=2.32.3",
     "spotipy>=2.25.1",