diff --git a/CLAUDE.md b/CLAUDE.md index 329b5e1..ddc3014 100644 --- a/CLAUDE.md +++ b/CLAUDE.md @@ -853,6 +853,11 @@ persistence) → GUI (Qt widgets that read the manager and connect to its signal API, so its `music.apple.com` page's `serialized-server-data` JSON is read — measured to hold every song (143 of 143), with album and length each. Private `/library/` playlists can't be read and aren't matched. + **The cover is kept** (`playlist_art.py`): a playlist made from a + Spotify/Apple link gets the link's cover in `/playlist_art/ + .jpg|png` (synced, never in the playlist JSON, so no merge or + "edited" stamp; downloaded on a daemon thread when the playlist is made). + Nothing displays it yet. **Several songs are identified as one batch** (Round 77, `identify_batch.py` + `gui/identify_batch_dialog.py`): an import of more than one song never pops a dialog mid-download. `IdentifyCollector` looks diff --git a/lintunes/__init__.py b/lintunes/__init__.py index b62a6ec..bc5065f 100644 --- a/lintunes/__init__.py +++ b/lintunes/__init__.py @@ -1,3 +1,3 @@ """LinTunes — iTunes-style music library manager and player for Linux.""" -__version__ = "0.93.0" +__version__ = "0.94.0" diff --git a/lintunes/apple_music_link.py b/lintunes/apple_music_link.py index 39463ad..9109e4a 100644 --- a/lintunes/apple_music_link.py +++ b/lintunes/apple_music_link.py @@ -159,6 +159,44 @@ def parse_playlist_page(html: str) -> tuple[str, list[SpotifyTrack]]: return name or "Apple Music", tracks +# The size a cover is asked for. Apple's artwork URLs are templates and +# scale server-side to whatever is asked. +COVER_SIZE = 1200 + + +def _artwork(template: str) -> str: + if not template: + return "" + return (template.replace("{w}", str(COVER_SIZE)) + .replace("{h}", str(COVER_SIZE)).replace("{f}", "jpg")) + + +def playlist_cover_url(html: str) -> str: + """A playlist page's cover image URL, or "" when it has none.""" + m = _SERVER_DATA.search(html or "") + try: + sections = json.loads(m.group(1))["data"][0]["data"]["sections"] + except (AttributeError, ValueError, KeyError, IndexError, TypeError): + return "" + for section in sections: + if section.get("itemKind") == "containerDetailHeaderLockup": + for item in section.get("items") or []: + url = (((item.get("artwork") or {}).get("dictionary") or {}) + .get("url")) + if url: + return _artwork(url) + return "" + + +def lookup_cover_url(data: dict) -> str: + """An iTunes Lookup answer's cover, at ``COVER_SIZE``, or "".""" + for r in (data or {}).get("results") or []: + url = r.get("artworkUrl100") or "" + if url and "100x100" in url: + return url.replace("100x100", f"{COVER_SIZE}x{COVER_SIZE}") + return "" + + # ---- network ---- def _get(url: str, **params) -> requests.Response: @@ -170,7 +208,8 @@ def _get(url: str, **params) -> requests.Response: def fetch(kind: str, source_id: str, - storefront: str = "us") -> tuple[str, list[SpotifyTrack]]: + storefront: str = "us") -> tuple[str, list[SpotifyTrack], str]: + """→ (the link's name, its songs, its cover image URL or "").""" if kind == "playlist": resp = _get(PLAYLIST_URL.format(storefront=storefront, id=source_id)) if resp.status_code == 404: @@ -178,7 +217,8 @@ def fetch(kind: str, source_id: str, "link (it may be private or deleted)") if not resp.ok: raise AppleMusicError(f"Apple Music answered {resp.status_code}") - return parse_playlist_page(resp.text) + return (*parse_playlist_page(resp.text), + playlist_cover_url(resp.text)) params = {"id": source_id, "country": storefront} if kind == "album": params["entity"] = "song" @@ -190,4 +230,4 @@ def fetch(kind: str, source_id: str, data = resp.json() except ValueError as e: raise AppleMusicError(f"Apple Music's answer couldn't be read: {e}") - return parse_lookup(data, kind) + return (*parse_lookup(data, kind), lookup_cover_url(data)) diff --git a/lintunes/gui/main_window.py b/lintunes/gui/main_window.py index fc1f78e..85145cc 100644 --- a/lintunes/gui/main_window.py +++ b/lintunes/gui/main_window.py @@ -13,6 +13,7 @@ from PyQt6.QtGui import QAction, QKeySequence from lintunes import (bpm_detect, device_sync, loudness, music_folder, shazam, tagging, theme, url_import) +from lintunes import playlist_art from lintunes.andtunes import layout as andtunes_layout from lintunes.andtunes import install as andtunes_install from lintunes.andtunes import sync as andtunes_sync @@ -304,6 +305,7 @@ class MainWindow(QMainWindow): # song lands, then the playlist's pid (made then, so a link that # downloads nothing leaves no empty playlist behind). self._url_new_name = "" + self._url_new_cover = "" self._url_new_pid = "" self._url_imported = 0 self._url_identify = True # False after "Stop Identifying" @@ -1933,6 +1935,7 @@ class MainWindow(QMainWindow): self._url_target = target if dialog.add_to_playlist() else None self._url_inserted = 0 self._url_new_name = dialog.new_playlist_name() + self._url_new_cover = dialog.new_playlist_cover() self._url_new_pid = "" self._url_imported = 0 self._url_identify = True @@ -2048,6 +2051,11 @@ class MainWindow(QMainWindow): playlist = self._manager.create_playlist(self._url_new_name) self._url_new_pid = playlist.persistent_id self._url_new_name = "" + if self._url_new_cover: # kept for later; nothing shows it yet + playlist_art.fetch_in_background( + self._url_new_cover, self._manager.data_dir, + playlist.persistent_id) + self._url_new_cover = "" self._manager.add_tracks_to_playlist( self._url_new_pid, [t.track_id for t in tracks], undoable=False) diff --git a/lintunes/gui/url_import_dialog.py b/lintunes/gui/url_import_dialog.py index 027bf65..2e39ab2 100644 --- a/lintunes/gui/url_import_dialog.py +++ b/lintunes/gui/url_import_dialog.py @@ -86,6 +86,7 @@ class UrlImportDialog(QDialog): self._seen: set[str] = set() # ids already listed (a Mix loops) self._just_song = False # "Just This Song" was pressed self._list_name = "" # what the link's list is called + self._list_cover = "" # its cover image's URL self.cookies_used = None # a browser the probe needed layout = QVBoxLayout(self) @@ -189,6 +190,10 @@ class UrlImportDialog(QDialog): return "" return self._make_name.text().strip() + def new_playlist_cover(self) -> str: + """The cover image URL for the new playlist ("" for none).""" + return self._list_cover if self.new_playlist_name() else "" + def download_urls(self) -> list[str]: """What to hand yt-dlp: the ticked songs' own pages, the linked song alone, or the link itself — never a list link the user didn't see.""" @@ -250,6 +255,7 @@ class UrlImportDialog(QDialog): self._seen = set() self._single = None self._list_name = "" + self._list_cover = "" self._url.setEnabled(False) self._just.setVisible(bool(self._linked)) catalog = _CATALOGS.get(self._kind) @@ -263,6 +269,8 @@ class UrlImportDialog(QDialog): url, cookies_browser=self._cookies) probe.entry.connect(self._on_entry) probe.named.connect(self._on_named) + if hasattr(probe, "cover"): + probe.cover.connect(self._on_cover) probe.finished.connect(self._on_probe_finished) probe.failed.connect(self._on_probe_failed) probe.cookies_used.connect(self._on_cookies_used) @@ -303,6 +311,10 @@ class UrlImportDialog(QDialog): if self._picking: self._show_make() + def _on_cover(self, url: str): + if self.sender() is self._probe: + self._list_cover = url + def _show_make(self): self._make.show() self._make_name.show() diff --git a/lintunes/playlist_art.py b/lintunes/playlist_art.py new file mode 100644 index 0000000..d1dc217 --- /dev/null +++ b/lintunes/playlist_art.py @@ -0,0 +1,95 @@ +"""A playlist's own cover image (Round 130). + +Spotify and Apple Music playlists (and albums) have a cover, and a playlist +made from one of their links in Import from URL keeps it. Nothing *shows* it +yet; this is only where it is kept. + +One file per playlist, ``/playlist_art/.jpg`` (or +``.png``), so it rides the Syncthing share with the playlists but stays out +of their JSON: a cover never makes a playlist look edited, and the conflict +merge never has to know about it. Only the machine that made the playlist +writes it. Writes are atomic (``.tmp`` → rename), like every JSON file. + +A deleted playlist's cover is left where it is: undo brings the playlist +back with the same id, and a cover is a few hundred KB. +""" +import logging +import os +import threading +from pathlib import Path + +import requests + +log = logging.getLogger(__name__) + +DIRNAME = "playlist_art" +TIMEOUT = 20 +MAX_BYTES = 10 * 1024 * 1024 +USER_AGENT = ("Mozilla/5.0 (X11; Linux x86_64; rv:131.0) " + "Gecko/20100101 Firefox/131.0") + +_SUFFIXES = (".jpg", ".png") + + +def image_suffix(data: bytes) -> str | None: + """".jpg" or ".png" by the bytes' own signature, else None.""" + if data[:3] == b"\xff\xd8\xff": + return ".jpg" + if data[:8] == b"\x89PNG\r\n\x1a\n": + return ".png" + return None + + +def find(data_dir: Path, pid: str) -> Path | None: + """The playlist's cover file, or None when it has none.""" + folder = Path(data_dir) / DIRNAME + for suffix in _SUFFIXES: + path = folder / f"{pid}{suffix}" + if path.is_file(): + return path + return None + + +def save(data_dir: Path, pid: str, data: bytes) -> Path: + """Keep ``data`` as the playlist's cover, replacing any other. Raises + ValueError for bytes that aren't a JPEG or PNG.""" + suffix = image_suffix(data) + if suffix is None: + raise ValueError("not a JPEG or PNG image") + if not pid or "/" in pid or pid.startswith("."): + raise ValueError(f"bad playlist id {pid!r}") + folder = Path(data_dir) / DIRNAME + folder.mkdir(parents=True, exist_ok=True) + path = folder / f"{pid}{suffix}" + tmp = path.with_name(path.name + ".tmp") + tmp.write_bytes(data) + os.replace(tmp, path) + for other in _SUFFIXES: + if other != suffix: + (folder / f"{pid}{other}").unlink(missing_ok=True) + return path + + +def download(url: str) -> bytes: + resp = requests.get(url, headers={"User-Agent": USER_AGENT}, + timeout=TIMEOUT, stream=True) + resp.raise_for_status() + data = b"" + for chunk in resp.iter_content(65536): + data += chunk + if len(data) > MAX_BYTES: + raise ValueError("cover image is too large") + return data + + +def fetch_in_background(url: str, data_dir: Path, pid: str): + """Download ``url`` and keep it as the playlist's cover, on a daemon + thread. A failure is logged and otherwise ignored: the playlist is + complete without it.""" + def run(): + try: + path = save(data_dir, pid, download(url)) + log.info("playlist art for %s saved to %s", pid, path) + except Exception as e: + log.warning("playlist art for %s from %s: %s", pid, url, e) + threading.Thread(target=run, daemon=True).start() diff --git a/lintunes/spotify_link.py b/lintunes/spotify_link.py index a77b722..441eb0f 100644 --- a/lintunes/spotify_link.py +++ b/lintunes/spotify_link.py @@ -163,6 +163,21 @@ def parse_embed(html: str) -> tuple[str, list[SpotifyTrack]]: return name, tracks +def cover_url(html: str) -> str: + """The embed page's cover image (the playlist's, album's or song's), + the largest it lists, or "" when it has none.""" + m = _NEXT_DATA.search(html or "") + try: + entity = _find_entity(json.loads(m.group(1))) if m else None + except ValueError: + return "" + sources = ((entity or {}).get("coverArt") or {}).get("sources") or [] + sources = [s for s in sources if isinstance(s, dict) and s.get("url")] + if not sources: + return "" + return max(sources, key=lambda s: s.get("width") or 0)["url"] + + def search_query(track: SpotifyTrack) -> str: return f"{track.artist} - {track.title}" if track.artist else track.title @@ -212,7 +227,8 @@ def tag_fields(track: SpotifyTrack) -> dict: # ---- network ---- -def fetch(kind: str, source_id: str) -> tuple[str, list[SpotifyTrack]]: +def fetch(kind: str, source_id: str) -> tuple[str, list[SpotifyTrack], str]: + """→ (the link's name, its songs, its cover image URL or "").""" url = EMBED_URL.format(kind=kind, id=source_id) try: resp = requests.get(url, headers={"User-Agent": USER_AGENT}, @@ -224,4 +240,4 @@ def fetch(kind: str, source_id: str) -> tuple[str, list[SpotifyTrack]]: "private or deleted)") if not resp.ok: raise SpotifyError(f"Spotify answered {resp.status_code}") - return parse_embed(resp.text) + return (*parse_embed(resp.text), cover_url(resp.text)) diff --git a/lintunes/url_import.py b/lintunes/url_import.py index df26e52..98d13a5 100644 --- a/lintunes/url_import.py +++ b/lintunes/url_import.py @@ -619,6 +619,12 @@ class UrlImportWorker(_YtdlpRun): # ---- Spotify ---- +def _with_cover(result) -> tuple: + """(name, songs, cover URL) from a fetch, which may leave the cover out + (the tests' canned fetches return only name and songs).""" + return (*result, "")[:3] + + class SpotifyProbe(QObject): """``PlaylistProbe``'s signals for a Spotify link: reads its embed page on a daemon thread and emits one entry per song, carrying the @@ -626,6 +632,7 @@ class SpotifyProbe(QObject): entry = pyqtSignal(dict) named = pyqtSignal(str) # the album's or playlist's name + cover = pyqtSignal(str) # its cover image's URL finished = pyqtSignal(int) failed = pyqtSignal(str) cookies_used = pyqtSignal(str) # never: Spotify needs no cookies @@ -648,20 +655,22 @@ class SpotifyProbe(QObject): threading.Thread(target=self._run, daemon=True).start() def _lookup(self): - """→ (is it a list, its name, its songs).""" + """→ (is it a list, its name, its songs, its cover URL or "").""" kind, source_id = spotify_link.spotify_source(self._url) - name, tracks = spotify_link.fetch(kind, source_id) - return kind != "track", name, tracks + return (kind != "track", *_with_cover(spotify_link.fetch(kind, + source_id))) def _run(self): try: - is_list, name, tracks = self._lookup() + is_list, name, tracks, cover = self._lookup() except Exception as e: self._busy = False self.failed.emit(str(e)) return if is_list: self.named.emit(name) + if cover: + self.cover.emit(cover) count = 0 for track in tracks: if self._cancel.is_set(): @@ -681,8 +690,8 @@ class AppleMusicProbe(SpotifyProbe): def _lookup(self): kind, source_id, storefront = apple_music_link.apple_source(self._url) - name, tracks = apple_music_link.fetch(kind, source_id, storefront) - return kind != "song", name, tracks + return (kind != "song", *_with_cover(apple_music_link.fetch( + kind, source_id, storefront))) class SpotifyImportWorker(UrlImportWorker): diff --git a/tests/test_round109.py b/tests/test_round109.py index ca82b9f..51e6990 100644 --- a/tests/test_round109.py +++ b/tests/test_round109.py @@ -154,7 +154,7 @@ def window(qapp, tmp_path, fake, monkeypatch): win.close() -def _import(window, qapp, monkeypatch, ids, name="Road Trip"): +def _import(window, qapp, monkeypatch, ids, name="Road Trip", cover=""): from lintunes.gui import main_window as mw chosen = [{"id": i, "title": f"Song {i}", "url": f"https://www.youtube.com/watch?v={i}"} for i in ids] @@ -169,6 +169,9 @@ def _import(window, qapp, monkeypatch, ids, name="Road Trip"): return False def new_playlist_name(self): return name + + def new_playlist_cover(self): + return cover def chosen_entries(self): return chosen def spotify_tracks(self): diff --git a/tests/test_round130.py b/tests/test_round130.py index 26e91f2..493a5bb 100644 --- a/tests/test_round130.py +++ b/tests/test_round130.py @@ -194,3 +194,77 @@ def test_an_apple_song_goes_straight_through(qapp, canned): _pump(qapp, lambda: dialog.result() == dialog.DialogCode.Accepted) assert [t.artist for t in dialog.spotify_tracks()] == ["Donald Fagen"] assert dialog.new_playlist_name() == "" + + +# -------------------------------------------------------------------------- +# D. the playlist's cover (kept, not shown yet) + +from lintunes import playlist_art # noqa: E402 +from tests.test_round109 import _import, _named, fake, window # noqa: E402,F401 + +JPEG = b"\xff\xd8\xff\xe0" + b"\0" * 32 +PNG = b"\x89PNG\r\n\x1a\n" + b"\0" * 32 + + +def test_cover_urls_are_read_off_every_kind_of_answer(): + page = PLAYLIST.replace( + '"trackCount": 2}', '"trackCount": 2, "artwork": {"dictionary": ' + '{"url": "https://is1-ssl.mzstatic.com/x/{w}x{h}bb.{f}"}}}') + assert apple_music_link.playlist_cover_url(page) == ( + "https://is1-ssl.mzstatic.com/x/1200x1200bb.jpg") + assert apple_music_link.playlist_cover_url(PLAYLIST) == "" + assert apple_music_link.lookup_cover_url({"results": [ + {"artworkUrl100": "https://a/b/100x100bb.jpg"}]}) == ( + "https://a/b/1200x1200bb.jpg") + embed = ('") + assert spotify_link.cover_url(embed) == "https://i.scdn.co/big" + assert spotify_link.cover_url("") == "" + + +def test_a_cover_is_kept_per_playlist_and_replaced(tmp_path): + assert playlist_art.find(tmp_path, "ABCD1234") is None + playlist_art.save(tmp_path, "ABCD1234", JPEG) + assert playlist_art.find(tmp_path, "ABCD1234").name == "ABCD1234.jpg" + playlist_art.save(tmp_path, "ABCD1234", PNG) # png replaces jpg + assert playlist_art.find(tmp_path, "ABCD1234").name == "ABCD1234.png" + assert sorted(p.name for p in (tmp_path / "playlist_art").iterdir()) == [ + "ABCD1234.png"] + with pytest.raises(ValueError): + playlist_art.save(tmp_path, "ABCD1234", b"not an image") + with pytest.raises(ValueError): + playlist_art.save(tmp_path, "../x", JPEG) + + +def test_the_probe_passes_the_cover_on_for_a_new_playlist(qapp, monkeypatch): + monkeypatch.setattr(apple_music_link, "fetch", lambda *a: ( + *parse_playlist_page(PLAYLIST), "https://img/cover.jpg")) + dialog = _dialog(qapp, PLAYLIST_URL) + dialog._on_import() + _pump(qapp, lambda: dialog._probe is None) + dialog._on_import() + assert dialog.new_playlist_cover() == "" # not ticked: no cover + dialog._make.setChecked(True) + assert dialog.new_playlist_cover() == "https://img/cover.jpg" + + +def test_the_new_playlist_gets_its_cover(window, qapp, fake, mp3_file, + monkeypatch): + monkeypatch.setenv("FAKE_YTDLP_AUDIO", str(mp3_file)) + monkeypatch.setattr(playlist_art, "download", lambda url: JPEG) + saved = [] + real_save = playlist_art.save + monkeypatch.setattr(playlist_art, "save", + lambda *a: saved.append(real_save(*a))) + manager = window._manager + _import(window, qapp, monkeypatch, ["aaa", "bbb"], cover="https://img/c") + [playlist] = _named(manager, "Road Trip") + _pump(qapp, lambda: saved) + assert playlist_art.find(manager.data_dir, playlist.persistent_id) \ + == saved[0] diff --git a/tests/test_round49.py b/tests/test_round49.py index d71b87b..471c658 100644 --- a/tests/test_round49.py +++ b/tests/test_round49.py @@ -349,6 +349,9 @@ class TestWindow: return True def new_playlist_name(self): return "" + + def new_playlist_cover(self): + return "" monkeypatch.setattr(mw, "UrlImportDialog", _Dialog) window._show_playlist("a") diff --git a/tests/test_round75.py b/tests/test_round75.py index e5ee88e..666caa8 100644 --- a/tests/test_round75.py +++ b/tests/test_round75.py @@ -365,6 +365,9 @@ def test_only_the_chosen_songs_download(window, qapp, fake, mp3_file, return False def new_playlist_name(self): return "" + + def new_playlist_cover(self): + return "" def chosen_entries(self): return chosen def spotify_tracks(self): @@ -413,6 +416,9 @@ def test_one_song_gets_no_progress_window(window, qapp, fake, mp3_file, return False def new_playlist_name(self): return "" + + def new_playlist_cover(self): + return "" def chosen_entries(self): return [] def spotify_tracks(self): diff --git a/tests/test_round76.py b/tests/test_round76.py index 6d5742c..5ecfb43 100644 --- a/tests/test_round76.py +++ b/tests/test_round76.py @@ -349,6 +349,9 @@ def test_spotify_songs_import_tagged_and_go_to_identify(window, qapp, fake, return False def new_playlist_name(self): return "" + + def new_playlist_cover(self): + return "" def chosen_entries(self): return chosen def spotify_tracks(self):