cassettify 0.1.0__tar.gz

cassettify-0.1.0/Formula/cassettify.rb

@@ -0,0 +1,19 @@
+class Cassettify < Formula
+  include Language::Python::Virtualenv
+
+  desc "Download your Spotify playlists for your iPod Classic"
+  homepage "https://github.com/bsolidgold/cassettify"
+  url "https://files.pythonhosted.org/packages/source/c/cassettify/cassettify-0.1.0.tar.gz"
+  sha256 "REPLACE_WITH_SHA256_AFTER_PYPI_RELEASE"
+  license "MIT"
+
+  depends_on "python@3.11"
+
+  def install
+    virtualenv_install_with_resources
+  end
+
+  test do
+    system bin/"cassettify", "--help"
+  end
+end

cassettify-0.1.0/PKG-INFO

@@ -0,0 +1,52 @@
+Metadata-Version: 2.4
+Name: cassettify
+Version: 0.1.0
+Summary: Download your Spotify playlists for your iPod Classic
+License: MIT
+Requires-Python: >=3.11
+Requires-Dist: requests>=2.31.0
+Requires-Dist: rich>=13.7.0
+Requires-Dist: spotdl>=4.2.0
+Requires-Dist: spotipy>=2.23.0
+Requires-Dist: textual>=0.47.0
+Requires-Dist: typer>=0.9.0
+Provides-Extra: dev
+Requires-Dist: pytest-asyncio>=0.21; extra == 'dev'
+Requires-Dist: pytest>=7.4; extra == 'dev'
+Description-Content-Type: text/markdown
+
+# cassettify
+
+Download your Spotify playlists for your iPod Classic.
+
+## Install
+
+```bash
+# via pip
+pip install cassettify
+
+# via Homebrew
+brew tap bsolidgold/cassettify
+brew install cassettify
+```
+
+## Usage
+
+```bash
+cassettify                          # interactive playlist picker
+cassettify "Dark Side of the Moon"  # download a specific playlist
+cassettify --all                    # download everything
+cassettify --output ~/Music/iPod    # set output directory
+cassettify --setup                  # re-run setup wizard
+```
+
+Songs are saved as: `<output>/<Artist>/<Album>/<track-number> - <title>.mp3`
+
+## First run
+
+Cassettify will walk you through connecting your Spotify account. You'll need
+to create a free app at developer.spotify.com — the wizard explains exactly how.
+
+## Notes
+
+Downloads via YouTube Music. Intended for personal archival use only.

cassettify-0.1.0/README.md

@@ -0,0 +1,35 @@
+# cassettify
+
+Download your Spotify playlists for your iPod Classic.
+
+## Install
+
+```bash
+# via pip
+pip install cassettify
+
+# via Homebrew
+brew tap bsolidgold/cassettify
+brew install cassettify
+```
+
+## Usage
+
+```bash
+cassettify                          # interactive playlist picker
+cassettify "Dark Side of the Moon"  # download a specific playlist
+cassettify --all                    # download everything
+cassettify --output ~/Music/iPod    # set output directory
+cassettify --setup                  # re-run setup wizard
+```
+
+Songs are saved as: `<output>/<Artist>/<Album>/<track-number> - <title>.mp3`
+
+## First run
+
+Cassettify will walk you through connecting your Spotify account. You'll need
+to create a free app at developer.spotify.com — the wizard explains exactly how.
+
+## Notes
+
+Downloads via YouTube Music. Intended for personal archival use only.

cassettify-0.1.0/cassettify/auth.py

@@ -0,0 +1,29 @@
+from __future__ import annotations
+import stat
+import spotipy
+from spotipy.oauth2 import SpotifyOAuth
+from cassettify.config import Config, CONFIG_DIR
+
+SCOPE = "playlist-read-private playlist-read-collaborative"
+_CACHE_PATH = str(CONFIG_DIR / ".spotify_cache")
+
+
+def get_client(config: Config) -> spotipy.Spotify:
+    auth_manager = SpotifyOAuth(
+        client_id=config.client_id,
+        client_secret=config.client_secret,
+        redirect_uri="http://localhost:8888/callback",
+        scope=SCOPE,
+        cache_path=_CACHE_PATH,
+        open_browser=True,
+    )
+    client = spotipy.Spotify(auth_manager=auth_manager)
+    _secure_cache_file()
+    return client
+
+
+def _secure_cache_file() -> None:
+    from pathlib import Path
+    cache = Path(_CACHE_PATH)
+    if cache.exists():
+        cache.chmod(stat.S_IRUSR | stat.S_IWUSR)  # 0o600

cassettify-0.1.0/cassettify/cache.py

@@ -0,0 +1,25 @@
+from __future__ import annotations
+import json
+from pathlib import Path
+
+CACHE_FILE = Path.home() / ".cassettify" / "cache.json"
+
+
+def load() -> set[str]:
+    if not CACHE_FILE.exists():
+        return set()
+    return set(json.loads(CACHE_FILE.read_text()))
+
+
+def add(track_id: str) -> None:
+    import os
+    ids = load()
+    ids.add(track_id)
+    CACHE_FILE.parent.mkdir(exist_ok=True)
+    tmp = CACHE_FILE.with_suffix(".tmp")
+    tmp.write_text(json.dumps(sorted(ids), indent=2))
+    os.replace(tmp, CACHE_FILE)
+
+
+def contains(track_id: str) -> bool:
+    return track_id in load()

cassettify-0.1.0/cassettify/cli.py

@@ -0,0 +1,66 @@
+from __future__ import annotations
+from pathlib import Path
+from typing import Optional
+import typer
+from cassettify.config import Config
+from cassettify.auth import get_client
+from cassettify.spotify import get_playlists, find_playlist_by_name
+from cassettify.ui.app import run_wizard, run_picker, run_downloads
+
+app = typer.Typer(
+    name="cassettify",
+    help="Download your Spotify playlists for your iPod Classic.",
+    add_completion=False,
+)
+
+
+def _ensure_config() -> Config:
+    config = Config.load()
+    if config is None:
+        typer.echo("First time setup — let's connect Spotify.")
+        config = run_wizard()
+    return config
+
+
+@app.callback(invoke_without_command=True)
+def main(
+    ctx: typer.Context,
+    playlist: Optional[str] = typer.Argument(
+        None, help="Name of a playlist to download (skips the picker)"
+    ),
+    all_playlists: bool = typer.Option(
+        False, "--all", "-a", help="Download every playlist"
+    ),
+    output: Optional[Path] = typer.Option(
+        None, "--output", "-o", help="Output directory (overrides saved default)"
+    ),
+    setup: bool = typer.Option(
+        False, "--setup", help="Re-run the first-time setup wizard"
+    ),
+) -> None:
+    if ctx.invoked_subcommand is not None:
+        return
+
+    if setup:
+        run_wizard()
+        return
+
+    config = _ensure_config()
+    output_dir = str(output) if output else config.output_dir
+    sp = get_client(config)
+
+    if all_playlists:
+        playlists = get_playlists(sp)
+    elif playlist:
+        all_pls = get_playlists(sp)
+        match = find_playlist_by_name(all_pls, playlist)
+        if not match:
+            typer.echo(f"Playlist '{playlist}' not found.", err=True)
+            raise typer.Exit(code=1)
+        playlists = [match]
+    else:
+        playlists = run_picker(sp)
+        if not playlists:
+            return
+
+    run_downloads(sp, playlists, output_dir)

cassettify-0.1.0/cassettify/config.py

@@ -0,0 +1,30 @@
+from __future__ import annotations
+import json
+import os
+from dataclasses import dataclass, asdict
+from pathlib import Path
+from typing import Optional
+
+CONFIG_DIR = Path.home() / ".cassettify"
+CONFIG_FILE = CONFIG_DIR / "config.json"
+
+
+@dataclass
+class Config:
+    client_id: str
+    client_secret: str
+    output_dir: str
+
+    @classmethod
+    def load(cls) -> Optional["Config"]:
+        if not CONFIG_FILE.exists():
+            return None
+        data = json.loads(CONFIG_FILE.read_text())
+        return cls(**data)
+
+    def save(self) -> None:
+        CONFIG_DIR.mkdir(mode=0o700, exist_ok=True)
+        CONFIG_DIR.chmod(0o700)  # re-apply in case dir already existed
+        fd = os.open(CONFIG_FILE, os.O_WRONLY | os.O_CREAT | os.O_TRUNC, 0o600)
+        with os.fdopen(fd, "w") as f:
+            json.dump(asdict(self), f, indent=2)

cassettify-0.1.0/cassettify/downloader.py

@@ -0,0 +1,42 @@
+from __future__ import annotations
+import subprocess
+import sys
+from pathlib import Path
+from cassettify.spotify import Track
+
+FAILED_LOG = Path.home() / ".cassettify" / "failed.log"
+
+_OUTPUT_TEMPLATE = "{artists}/{album}/{track-number} - {title}.{output-ext}"
+
+
+def download_track(track: Track, output_dir: str) -> bool:
+    """Download a single track via spotdl. Returns True on success."""
+    full_template = str(Path(output_dir) / _OUTPUT_TEMPLATE)
+    try:
+        result = subprocess.run(
+            [
+                sys.executable, "-m", "spotdl",
+                track.spotify_url,
+                "--output", full_template,
+                "--format", "mp3",
+            ],
+            capture_output=True,
+            text=True,
+            timeout=120,
+        )
+        if result.returncode != 0:
+            _log_failure(track, result.stderr.strip())
+            return False
+        return True
+    except subprocess.TimeoutExpired:
+        _log_failure(track, "timeout after 120s")
+        return False
+    except Exception as e:
+        _log_failure(track, str(e))
+        return False
+
+
+def _log_failure(track: Track, reason: str) -> None:
+    FAILED_LOG.parent.mkdir(exist_ok=True)
+    with FAILED_LOG.open("a") as f:
+        f.write(f"{track.artist} - {track.name} ({track.id}): {reason}\n")

cassettify-0.1.0/cassettify/spotify.py

@@ -0,0 +1,72 @@
+from __future__ import annotations
+from dataclasses import dataclass
+from typing import Optional
+import spotipy
+
+
+@dataclass
+class Track:
+    id: str
+    name: str
+    artist: str
+    album: str
+    album_art_url: Optional[str]
+    spotify_url: str
+
+
+@dataclass
+class Playlist:
+    id: str
+    name: str
+    track_count: int
+    cover_url: Optional[str]
+
+
+def get_playlists(sp: spotipy.Spotify) -> list[Playlist]:
+    playlists = []
+    results = sp.current_user_playlists(limit=50)
+    while results:
+        for item in results["items"]:
+            cover = item["images"][0]["url"] if item["images"] else None
+            playlists.append(Playlist(
+                id=item["id"],
+                name=item["name"],
+                track_count=item["tracks"]["total"],
+                cover_url=cover,
+            ))
+        results = sp.next(results) if results["next"] else None
+    return playlists
+
+
+def get_tracks(sp: spotipy.Spotify, playlist_id: str) -> list[Track]:
+    tracks = []
+    results = sp.playlist_tracks(playlist_id)
+    while results:
+        for item in results["items"]:
+            t = item.get("track")
+            if not t or t.get("is_local") or not t.get("id"):
+                continue
+            spotify_url = t.get("external_urls", {}).get("spotify", "")
+            if not spotify_url:
+                continue
+            art = t["album"]["images"][0]["url"] if t["album"]["images"] else None
+            tracks.append(Track(
+                id=t["id"],
+                name=t["name"],
+                artist=t["artists"][0]["name"] if t.get("artists") else "Unknown Artist",
+                album=t["album"]["name"],
+                album_art_url=art,
+                spotify_url=spotify_url,
+            ))
+        results = sp.next(results) if results["next"] else None
+    return tracks
+
+
+def find_playlist_by_name(
+    playlists: list[Playlist], name: str
+) -> Optional[Playlist]:
+    name_lower = name.lower()
+    for p in playlists:
+        if p.name.lower() == name_lower:
+            return p
+    return None

cassettify-0.1.0/cassettify/ui/app.py

@@ -0,0 +1,57 @@
+from __future__ import annotations
+import spotipy
+from cassettify.config import Config
+from cassettify.auth import get_client
+from cassettify.spotify import get_playlists, get_tracks, Playlist
+from cassettify import cache
+from cassettify.downloader import download_track
+from cassettify.ui.wizard import WizardApp
+from cassettify.ui.picker import PickerApp
+from cassettify.ui.progress import ProgressApp
+
+
+def run_wizard() -> Config:
+    """Run the first-run setup wizard. Saves and returns Config."""
+    import typer
+    result = WizardApp().run()
+    if result is None:
+        typer.echo("Setup cancelled.")
+        raise typer.Exit(code=0)
+    config = Config(
+        client_id=result.client_id,
+        client_secret=result.client_secret,
+        output_dir=result.output_dir,
+    )
+    config.save()
+    return config
+
+
+def run_picker(sp: spotipy.Spotify) -> list[Playlist]:
+    """Run the interactive playlist picker. Returns selected playlists."""
+    playlists = get_playlists(sp)
+    if not playlists:
+        return []
+    return PickerApp(playlists).run() or []
+
+
+def run_downloads(
+    sp: spotipy.Spotify, playlists: list[Playlist], output_dir: str
+) -> None:
+    """Collect tracks from playlists, skip cached, run the progress UI."""
+    all_tracks = []
+    for playlist in playlists:
+        tracks = get_tracks(sp, playlist.id)
+        new = [t for t in tracks if not cache.contains(t.id)]
+        all_tracks.extend(new)
+
+    if not all_tracks:
+        print("Nothing new to download — all tracks already in cache.")
+        return
+
+    def download_and_cache(track):
+        success = download_track(track, output_dir)
+        if success:
+            cache.add(track.id)
+        return success
+
+    ProgressApp(all_tracks, download_and_cache).run()

cassettify-0.1.0/cassettify/ui/picker.py

@@ -0,0 +1,78 @@
+from __future__ import annotations
+from textual.app import App, ComposeResult
+from textual.widgets import DataTable, Input, Static, Footer, Header
+from textual.containers import Vertical
+from textual import on
+from cassettify.spotify import Playlist
+
+
+class PickerApp(App):
+    """Interactive playlist picker. Returns list of selected Playlist objects."""
+
+    BINDINGS = [
+        ("space", "toggle_selection", "Select"),
+        ("enter", "confirm", "Download"),
+        ("escape", "quit_app", "Quit"),
+    ]
+
+    CSS = """
+    #search { dock: top; margin: 1 2; }
+    #status { dock: bottom; height: 1; margin: 0 2; color: $text-muted; }
+    DataTable { margin: 0 2; }
+    """
+
+    def __init__(self, playlists: list[Playlist]) -> None:
+        super().__init__()
+        self._all = playlists
+        self._filtered = list(playlists)
+        self._selected: set[str] = set()
+
+    def compose(self) -> ComposeResult:
+        yield Header(show_clock=False)
+        yield Input(placeholder="Search playlists...", id="search")
+        yield DataTable(id="table", cursor_type="row")
+        yield Static("", id="status")
+        yield Footer()
+
+    def on_mount(self) -> None:
+        table = self.query_one(DataTable)
+        table.add_columns("", "Playlist", "Tracks")
+        self._refresh_table()
+
+    def _refresh_table(self) -> None:
+        table = self.query_one(DataTable)
+        table.clear()
+        for p in self._filtered:
+            check = "✓" if p.id in self._selected else " "
+            table.add_row(check, p.name, str(p.track_count), key=p.id)
+        n = len(self._selected)
+        self.query_one("#status", Static).update(
+            f"{n} playlist{'s' if n != 1 else ''} selected  ·  "
+            "Space to toggle  ·  Enter to download  ·  Esc to quit"
+        )
+
+    @on(Input.Changed, "#search")
+    def filter_playlists(self, event: Input.Changed) -> None:
+        q = event.value.lower()
+        self._filtered = [p for p in self._all if q in p.name.lower()]
+        self._refresh_table()
+
+    def action_toggle_selection(self) -> None:
+        table = self.query_one(DataTable)
+        row_index = table.cursor_row
+        if row_index is None or row_index >= len(self._filtered):
+            return
+        playlist_id = self._filtered[row_index].id
+        if playlist_id in self._selected:
+            self._selected.discard(playlist_id)
+        else:
+            self._selected.add(playlist_id)
+        self._refresh_table()
+        table.move_cursor(row=row_index)
+
+    def action_confirm(self) -> None:
+        selected = [p for p in self._all if p.id in self._selected]
+        self.exit(selected if selected else None)
+
+    def action_quit_app(self) -> None:
+        self.exit(None)

cassettify-0.1.0/cassettify/ui/progress.py

@@ -0,0 +1,115 @@
+from __future__ import annotations
+import asyncio
+from typing import Callable
+from textual.app import App, ComposeResult
+from textual.widgets import (
+    Static, ProgressBar, ListView, ListItem, Label, Header, Footer
+)
+from textual.containers import Horizontal, Vertical, Container
+from textual.reactive import reactive
+from cassettify.spotify import Track
+
+
+class ProgressApp(App):
+    """Download progress display. Calls download_fn(track) -> bool per track."""
+
+    BINDINGS = [("q", "quit_app", "Quit")]
+
+    CSS = """
+    #now-playing {
+        height: 9;
+        border: solid $primary;
+        margin: 1 2;
+        padding: 1 2;
+    }
+    #art {
+        width: 10;
+        height: 5;
+        border: solid $primary;
+        margin-right: 2;
+        content-align: center middle;
+        color: $text-muted;
+    }
+    #track-info { height: 5; width: 1fr; }
+    #track-name { text-style: bold; }
+    #artist-album { color: $text-muted; margin-bottom: 1; }
+    #panels { height: 1fr; margin: 0 2; }
+    #queue-panel, #done-panel { height: 1fr; width: 1fr; border: solid $surface; padding: 1; }
+    .panel-title { color: $text-muted; margin-bottom: 1; }
+    .done-label { color: $success; }
+    .fail-label { color: $error; }
+    """
+
+    def __init__(self, tracks: list[Track], download_fn: Callable[[Track], bool]) -> None:
+        super().__init__()
+        self._tracks = tracks
+        self._download_fn = download_fn
+
+    def compose(self) -> ComposeResult:
+        yield Header(show_clock=False)
+        yield Container(
+            Horizontal(
+                Static("♫", id="art"),
+                Vertical(
+                    Static("Preparing...", id="track-name"),
+                    Static("", id="artist-album"),
+                    ProgressBar(total=len(self._tracks), show_eta=False, id="progress"),
+                    id="track-info",
+                ),
+                id="now-playing",
+            ),
+        )
+        yield Horizontal(
+            Vertical(
+                Static(f"Queue ({len(self._tracks)} tracks)", classes="panel-title", id="queue-title"),
+                ListView(id="queue"),
+                id="queue-panel",
+            ),
+            Vertical(
+                Static("✓ Done", classes="panel-title"),
+                ListView(id="done"),
+                id="done-panel",
+            ),
+            id="panels",
+        )
+        yield Footer()
+
+    def on_mount(self) -> None:
+        queue = self.query_one("#queue", ListView)
+        for t in self._tracks:
+            queue.append(ListItem(Label(f"  {t.artist} — {t.name}"), id=f"q-{t.id}"))
+        self.run_worker(self._run_downloads())
+
+    async def _run_downloads(self) -> None:
+        done_count = 0
+        for track in self._tracks:
+            self.query_one("#track-name", Static).update(f"[bold]{track.name}[/bold]")
+            self.query_one("#artist-album", Static).update(
+                f"{track.artist}  ·  {track.album}"
+            )
+            try:
+                self.query_one(f"#q-{track.id}").remove()
+            except Exception:
+                pass
+            remaining = len(self._tracks) - done_count - 1
+            self.query_one("#queue-title", Static).update(
+                f"Queue ({remaining} remaining)"
+            )
+
+            success = await asyncio.to_thread(self._download_fn, track)
+            done_count += 1
+            self.query_one("#progress", ProgressBar).advance(1)
+
+            done_list = self.query_one("#done", ListView)
+            if success:
+                await done_list.append(ListItem(Label(f"✓ {track.name}", classes="done-label")))
+            else:
+                await done_list.append(ListItem(Label(f"✗ {track.name}", classes="fail-label")))
+
+        self.query_one("#track-name", Static).update(
+            f"[bold green]All done![/bold green]  {done_count}/{len(self._tracks)} tracks downloaded"
+        )
+        self.query_one("#artist-album", Static).update("Press Q to quit")
+
+    def action_quit_app(self) -> None:
+        self.exit()