diff --git a/CLAUDE.md b/CLAUDE.md index 5a84f7f..1431c7c 100644 --- a/CLAUDE.md +++ b/CLAUDE.md @@ -242,6 +242,9 @@ persistence) → GUI (Qt widgets that read the manager and connect to its signal Its words are `transport.NowPlayingText` (Round 130): the title on the left with artist over album beside it when all of it fits the width, else the old stack (title over "Artist — Album", elided with "…"). + Side by side the words grow to fill the panel (title up to its full + height, the two lines up to half each, by one shared share as far as + the width allows); the stack keeps the normal sizes. Decided from the text's widths on every resize and song; DJ mode's lines (`set_lines`) always stack. **The look is `~/Documents/shared-resources/design.html`** (canonical @@ -862,7 +865,16 @@ persistence) → GUI (Qt widgets that read the manager and connect to its signal 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. + The sidebar art panel shows the *shown* playlist's cover while nothing + is playing (`SidebarArt.set_playlist_art`, fed by + `MainWindow._update_playlist_art`); a song's art always wins. + **Songs already owned** (`library_match.LibraryMatcher`, Shazam's rule + plus a ±15 s length check) are listed "already in your library" and + unticked; `link_rows()` keeps them in the list's order as the library's + copy, and `MainWindow._place_url_rows` fills the playlists in the link's + order as downloads land (a pending download holds back what follows, a + failed one is skipped, the rest go in when the worker ends) — so the + playlist comes out the same and only new songs download. **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 877f30f..d439943 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.95.0" +__version__ = "0.96.0" diff --git a/lintunes/gui/main_window.py b/lintunes/gui/main_window.py index 85145cc..08cf0c4 100644 --- a/lintunes/gui/main_window.py +++ b/lintunes/gui/main_window.py @@ -115,6 +115,9 @@ _CURRENT_TARGET = object() class MainWindow(QMainWindow): + # A playlist's cover finished downloading (emitted off the GUI thread). + _playlist_art_saved = pyqtSignal(str) + def __init__(self, manager, prefs, lastfm=None, parent=None): super().__init__(parent) self._manager = manager @@ -307,6 +310,10 @@ class MainWindow(QMainWindow): self._url_new_name = "" self._url_new_cover = "" self._url_new_pid = "" + self._url_rows = None # a Spotify/Apple list, in order + self._url_owned = 0 + self._url_placed = 0 + self._url_current = "" self._url_imported = 0 self._url_identify = True # False after "Stop Identifying" self._url_note = "" @@ -348,6 +355,8 @@ class MainWindow(QMainWindow): self._sidebar.art.download_art_requested.connect( lambda tid: self._download_album_art([tid])) self._content.currentChanged.connect(self._update_totals) + self._content.currentChanged.connect(self._update_playlist_art) + self._playlist_art_saved.connect(self._update_playlist_art) for view in (self._library_view, self._playlist_view): view.play_requested.connect( lambda ids, start, v=view: self._play_from_view(v, ids, start)) @@ -1541,6 +1550,19 @@ class MainWindow(QMainWindow): self._playlist_view.show_playlist(playlist) self._content.setCurrentWidget(self._playlist_view) self._update_now_playing_icon() + self._update_playlist_art() + + def _update_playlist_art(self, *_): + """Hand the art panel the shown playlist's cover (it shows it only + while nothing is playing).""" + path, name = None, "" + if self._content.currentWidget() is self._playlist_view: + pid = self._playlist_view.playlist_id + playlist = self._manager.library.playlists.get(pid) + if playlist is not None: + path = playlist_art.find(self._manager.data_dir, pid) + name = playlist.name + self._sidebar.art.set_playlist_art(path, name) def _go_to_current_song(self): """Jump to wherever the current song is playing from, select it, and @@ -1921,8 +1943,10 @@ class MainWindow(QMainWindow): return target = self._url_import_target() cookies = load_config().get(url_import.COOKIES_KEY) - dialog = UrlImportDialog(target.description if target else None, self, - cookies_browser=cookies) + dialog = UrlImportDialog( + target.description if target else None, self, + cookies_browser=cookies, + library_tracks=lambda: self._manager.library.tracks.values()) accepted = dialog.exec() if dialog.cookies_used: # the listing needed them self._remember_cookies_browser(dialog.cookies_used) @@ -1944,6 +1968,22 @@ class MainWindow(QMainWindow): if problem else "") spotify = dialog.spotify_tracks() + # A Spotify/Apple list: its songs in order, the ones the library + # already has standing in as themselves (placed by _place_url_rows). + self._url_rows = dialog.link_rows() + self._url_placed = 0 + self._url_current = "" + self._url_owned = sum(1 for r in self._url_rows or [] if r["owned"]) + if self._url_rows is not None and not spotify: + self._place_url_rows(final=True) # nothing to download + owned = sum(1 for r in self._url_rows if r["owned"]) + self.statusBar().showMessage( + f"{owned} song{'' if owned == 1 else 's'} already in your " + "library" + (", added to the playlist" if owned and ( + self._url_target is not None or self._url_new_pid) + else "") + " · nothing to download", 12000) + self._url_rows = None + return if self._url_batch is not None: self._url_batch.cancel() self._url_batch = None @@ -1978,6 +2018,7 @@ class MainWindow(QMainWindow): self._url_progress.show() worker.cookies_used.connect(self._remember_cookies_browser) worker.item_started.connect(self._on_url_item_started) + worker.item_failed.connect(self._on_url_item_failed) worker.progress.connect(self._sync_progress.setValue) worker.downloaded.connect(self._on_url_downloaded) worker.finished.connect(self._on_url_finished) @@ -2009,6 +2050,7 @@ class MainWindow(QMainWindow): def _on_url_item_started(self, index: int, count: int, item_id: str, title: str): + self._url_current = item_id if self._url_progress is not None: self._url_progress.started(item_id) short = title if len(title) <= 40 else title[:39] + "…" @@ -2016,9 +2058,63 @@ class MainWindow(QMainWindow): self._sync_label.setText(f"Downloading {where}{short}") self._sync_progress.setValue(0) + def _place_url_rows(self, final: bool = False): + """Put a Spotify/Apple list's songs into the playlists in the link's + order, as far as they're known: an owned song or a landed download + goes in, a song still downloading holds back everything after it, + a failed one is skipped. ``final``: nothing more is coming.""" + rows = self._url_rows or [] + ready = [] + while self._url_placed < len(rows): + row = rows[self._url_placed] + if row["download"] and row["owned"] is None and not final: + break # still to land (or fail) + self._url_placed += 1 + if row["owned"] is not None \ + and row["owned"] in self._manager.library.tracks: + ready.append(row["owned"]) + if not ready: + return + target = self._url_target + if target is not None and target.pid in self._manager.library.playlists: + position = (None if target.position is None + else target.position + self._url_inserted) + self._manager.add_tracks_to_playlist(target.pid, ready, position) + self._url_inserted += len(ready) + if self._url_new_name or self._url_new_pid: + self._add_to_new_url_playlist( + [self._manager.library.tracks[t] for t in ready]) + + def _url_row_done(self, key: str, track_id): + """A download of a Spotify/Apple list's song landed (a track id) or + failed (None).""" + for row in self._url_rows or []: + if row["key"] == key and row["download"] and row["owned"] is None: + row["owned"] = track_id + row["download"] = track_id is not None + break + self._place_url_rows() + + def _on_url_item_failed(self, key: str, _reason: str = ""): + if self._url_rows is not None: + self._url_row_done(key, None) + def _on_url_downloaded(self, path: str): """One song is off the network: file it and identify it now, so the first dialog can be up while the rest are still downloading.""" + if self._url_rows is not None: + imported = self.import_files([Path(path)]) + self._url_row_done(self._url_current, + imported[0].track_id if imported else None) + self._url_imported += len(imported) + if self._url_progress is not None: + self._url_progress.landed(bool(imported)) + if imported and self._url_identify: + if self._url_batch is not None: + self._url_batch.add(imported) + else: + self._enqueue_identify(imported) + return target = self._url_target pid, position = "", None if target is not None and target.pid in self._manager.library.playlists: @@ -2051,15 +2147,19 @@ 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 + if self._url_new_cover: # shown by the art panel playlist_art.fetch_in_background( self._url_new_cover, self._manager.data_dir, - playlist.persistent_id) + playlist.persistent_id, + saved=self._playlist_art_saved.emit) self._url_new_cover = "" self._manager.add_tracks_to_playlist( self._url_new_pid, [t.track_id for t in tracks], undoable=False) def _finish_url_import(self): + if self._url_rows is not None: + self._place_url_rows(final=True) # the rest, in order + self._url_rows = None if self._url_worker is not None: self._url_worker.cleanup() self._hide_sync_widgets() @@ -2195,6 +2295,11 @@ class MainWindow(QMainWindow): if target is not None else None) if playlist is not None and count: msg += f" into “{playlist.name}”" + owned = self._url_owned + if owned: + msg += f" · {owned} already in your library" + if self._url_target is not None or self._url_new_pid: + msg += f", added in {'its' if owned == 1 else 'their'} place" if summary["errors"]: msg += f" · {len(summary['errors'])} couldn't be downloaded" if self._url_note and count and self._url_identify: diff --git a/lintunes/gui/sidebar.py b/lintunes/gui/sidebar.py index 258e0f8..8312233 100644 --- a/lintunes/gui/sidebar.py +++ b/lintunes/gui/sidebar.py @@ -316,7 +316,12 @@ class SidebarArt(QWidget): window below the playlist list's frame, like the visualizer, with the cover inside its border. With no embedded art the panel is empty. A click opens the big art window, or, on the empty panel, asks for the - track's art to be downloaded.""" + track's art to be downloaded. + + With nothing playing, the shown playlist's own cover (Round 130, + ``playlist_art``) stands in, when it has one: the playing song's art + always wins, so the panel only shows a playlist's when there's no + song's to show.""" download_art_requested = pyqtSignal(int) # track id has_art_changed = pyqtSignal(bool) @@ -326,6 +331,9 @@ class SidebarArt(QWidget): self._player = player self._pixmap: QPixmap | None = None self._track = None + self._playlist_pixmap: QPixmap | None = None + self._playlist_title = "" + self._showing_playlist = False self._art_window = ArtWindow() self._hovered = False self._held = False @@ -335,6 +343,22 @@ class SidebarArt(QWidget): self.setFocusPolicy(Qt.FocusPolicy.TabFocus) player.track_changed.connect(self.set_track) + def set_playlist_art(self, path, title: str = ""): + """The shown playlist's cover file (None: no playlist shown, or one + with no cover), shown while nothing is playing.""" + pixmap = None + if path is not None: + pixmap = QPixmap(str(path)) + if pixmap.isNull(): + pixmap = None + self._playlist_pixmap = pixmap + self._playlist_title = title + if self._track is None: + self.set_track(None) + + def showing_playlist_art(self) -> bool: + return self._showing_playlist + def set_track(self, track): self._track = track self._pixmap = None @@ -344,6 +368,10 @@ class SidebarArt(QWidget): pixmap = QPixmap() if pixmap.loadFromData(data): self._pixmap = pixmap + self._showing_playlist = (track is None + and self._playlist_pixmap is not None) + if self._showing_playlist: + self._pixmap = self._playlist_pixmap self._update_cursor() if self._pixmap is not None: self.setToolTip("Click to view full size") @@ -375,6 +403,8 @@ class SidebarArt(QWidget): self.set_track(self._track) def _title(self) -> str: + if self._showing_playlist: + return self._playlist_title or "Playlist Art" if self._track is None: return "Album Art" return (" — ".join(p for p in (self._track.artist, self._track.album) if p) diff --git a/lintunes/gui/transport.py b/lintunes/gui/transport.py index 9324a57..a1e8dba 100644 --- a/lintunes/gui/transport.py +++ b/lintunes/gui/transport.py @@ -5,7 +5,8 @@ from PyQt6.QtWidgets import ( QPushButton, QSizePolicy, QStyle, QStyleOptionSlider, QLayout, QSpacerItem, ) from PyQt6.QtCore import Qt, QTimer, QEvent, QPoint, QPointF, QRect, QSize, pyqtSignal -from PyQt6.QtGui import QColor, QFont, QIcon, QPainter, QPen, QPixmap +from PyQt6.QtGui import (QColor, QFont, QFontInfo, QFontMetrics, QIcon, + QPainter, QPen, QPixmap) from lintunes.tap_tempo import TapTempo from lintunes.gui.icons import transport_icon @@ -161,10 +162,16 @@ class NowPlayingText(QWidget): from the text's own widths on every resize and every new song, so the side-by-side shape is only ever used when nothing in it is cut off. - The labels' fonts are set by ``TransportBar._apply_now_playing_font``, - which calls ``arrange()`` after.""" + Side by side, the words grow to fill the panel: the title up to the + whole height, artist and album up to half of it each, both by the same + share of the way from their normal size to that, as far as the width + allows (trav: "the song title should really max out that space"). The + stack keeps the normal sizes. - GAP = 18 # between the title and the artist/album column + The normal fonts come from ``TransportBar._apply_now_playing_font`` + through ``set_fonts``.""" + + GAP = 18 # least space between the title and the column LINE_GAP = 2 # between stacked lines def __init__(self, parent=None): @@ -174,9 +181,17 @@ class NowPlayingText(QWidget): self.album = QLabel(self) self._song: tuple[str, str, str] | None = None self._lines = ("", "") + self._title_font = QFont(self.title.font()) + self._line_font = QFont(self.artist.font()) self.side = False # side by side, as last arranged self.arrange() + def set_fonts(self, title: QFont, line: QFont): + """The normal (stacked) sizes; side by side grows from these.""" + self._title_font = QFont(title) + self._line_font = QFont(line) + self.arrange() + def sizeHint(self): return QSize(200, self.minimumSizeHint().height()) @@ -197,15 +212,69 @@ class NowPlayingText(QWidget): def _width(self, label: QLabel, text: str) -> int: return label.fontMetrics().horizontalAdvance(text) if text else 0 - def fits_side(self, width: int) -> bool: + @staticmethod + def _sized(font: QFont, px: float) -> QFont: + sized = QFont(font) + sized.setPixelSize(max(1, round(px))) + return sized + + @classmethod + def _largest_px(cls, font: QFont, height: int, lines: int) -> int: + """The biggest pixel size at which ``lines`` lines fit ``height``.""" + lo, hi = 1, max(2, height * 2) + while lo < hi: + mid = (lo + hi + 1) // 2 + line = QFontMetrics(cls._sized(font, mid)).height() + if line * lines + cls.LINE_GAP * (lines - 1) <= height: + lo = mid + else: + hi = mid - 1 + return lo + + def side_fonts(self, width: int, height: int): + """(title font, line font, gap) for side by side at this size, as + big as fits; None when even the normal sizes don't fit.""" if self._song is None: - return False + return None title, artist, album = self._song - if not title or not (artist or album): - return False - right = max(self._width(self.artist, artist), - self._width(self.album, album)) - return self._width(self.title, title) + self.GAP + right <= width + right = [t for t in (artist, album) if t] + if not title or not right: + return None + base_t = QFontInfo(self._title_font).pixelSize() + base_l = QFontInfo(self._line_font).pixelSize() + top_t = max(base_t, self._largest_px(self._title_font, height, 1)) + top_l = max(base_l, self._largest_px(self._line_font, height, + len(right))) + + def at(share): + tf = self._sized(self._title_font, + base_t + share * (top_t - base_t)) + lf = self._sized(self._line_font, + base_l + share * (top_l - base_l)) + gap = max(self.GAP, round(tf.pixelSize() * 0.6)) + line = QFontMetrics(lf) + need = (QFontMetrics(tf).horizontalAdvance(title) + gap + + max(line.horizontalAdvance(t) for t in right)) + return need <= width, (tf, lf, gap) + + fits, fonts = at(1.0) + if fits: + return fonts + fits, fonts = at(0.0) + if not fits: + return None + lo, hi = 0.0, 1.0 + for _ in range(12): + mid = (lo + hi) / 2 + ok, found = at(mid) + if ok: + lo, fonts = mid, found + else: + hi = mid + return fonts + + def fits_side(self, width: int) -> bool: + return self.side_fonts(width, max(1, self.height())) is not None def resizeEvent(self, event): super().resizeEvent(event) @@ -213,10 +282,15 @@ class NowPlayingText(QWidget): def arrange(self): w, h = self.width(), self.height() - self.side = self.fits_side(w) + fonts = self.side_fonts(w, h) + self.side = fonts is not None left = Qt.AlignmentFlag.AlignLeft | Qt.AlignmentFlag.AlignVCenter centre = Qt.AlignmentFlag.AlignCenter if self.side: + title_font, line_font, gap = fonts + self.title.setFont(title_font) + self.artist.setFont(line_font) + self.album.setFont(line_font) title, artist, album = self._song self.title.setText(title) self.artist.setText(artist) @@ -224,7 +298,7 @@ class NowPlayingText(QWidget): tw = self._width(self.title, title) rw = max(self._width(self.artist, artist), self._width(self.album, album)) - x = max(0, (w - (tw + self.GAP + rw)) // 2) + x = max(0, (w - (tw + gap + rw)) // 2) self.title.setAlignment(left) self.title.setGeometry(x, 0, tw + 1, h) column = [lab for lab, text in ((self.artist, artist), @@ -233,7 +307,7 @@ class NowPlayingText(QWidget): y = (h - sum(heights) - self.LINE_GAP * (len(column) - 1)) // 2 for lab, lh in zip(column, heights): lab.setAlignment(left) - lab.setGeometry(x + tw + self.GAP, y, rw + 1, lh) + lab.setGeometry(x + tw + gap, y, rw + 1, lh) y += lh + self.LINE_GAP self.artist.setVisible(bool(artist)) self.album.setVisible(bool(album)) @@ -245,6 +319,8 @@ class NowPlayingText(QWidget): bottom = " — ".join(p for p in (artist, album) if p) else: top, bottom = self._lines + self.title.setFont(self._title_font) + self.artist.setFont(self._line_font) # Too long for the panel: an ellipsis, never both ends cut off. elide = Qt.TextElideMode.ElideRight self.title.setText(self.title.fontMetrics().elidedText(top, elide, w)) @@ -1250,13 +1326,15 @@ class TransportBar(QWidget): family = theme.now_playing_font_family(self._prefs) base_pt = self.font().pointSize() text_color = theme.gray(theme.gray_value(self._prefs, "color_now_playing_text")) - for label, delta in ((self._title_label, TITLE_PT_BUMP), - (self._artist_label, 0), (self._album_label, 0)): + fonts = [] + for delta in (TITLE_PT_BUMP, 0): font = QFont(family) if family else QFont(self.font()) font.setPointSize(max(1, base_pt + delta)) - label.setFont(font) + fonts.append(font) + for label in (self._title_label, self._artist_label, + self._album_label): label.setStyleSheet(f"color: {text_color.name()};") - self._np_text.arrange() + self._np_text.set_fonts(*fonts) # ---- player events ---- diff --git a/lintunes/gui/url_import_dialog.py b/lintunes/gui/url_import_dialog.py index 2e39ab2..7df775f 100644 --- a/lintunes/gui/url_import_dialog.py +++ b/lintunes/gui/url_import_dialog.py @@ -29,6 +29,13 @@ A list that has a name (a YouTube or SoundCloud playlist, a Spotify or Apple Music album or playlist) offers to make a new playlist of the same name holding every song imported (``new_playlist_name()``). Off unless ticked; the name can be edited first. + +Since Round 130 a Spotify or Apple Music list is checked against the +library (``library_match``) as it fills: a song already here is listed +"already in your library" and unticked. It still goes into the playlists, +as the copy already here, in its place (``link_rows()``), so the playlist +comes out the same and only the new songs download. Ticking it downloads +it again. """ from urllib.parse import parse_qs, urlsplit @@ -39,6 +46,7 @@ from PyQt6.QtWidgets import ( QVBoxLayout, ) +from lintunes.library_match import LibraryMatcher from lintunes.url_import import ( AppleMusicProbe, PlaylistProbe, SpotifyProbe, link_kind, looks_like_url, ) @@ -72,8 +80,12 @@ def linked_song_id(url: str) -> str: class UrlImportDialog(QDialog): def __init__(self, target_description: str | None, parent=None, *, - cookies_browser: str | None = None): + cookies_browser: str | None = None, library_tracks=None): + """``library_tracks``: a callable giving the library's tracks, to + find the songs of a Spotify/Apple list it already has.""" super().__init__(parent) + self._library_tracks = library_tracks + self._matcher = None self.setWindowTitle("Import from URL") self.setMinimumWidth(460) self._cookies = cookies_browser @@ -203,14 +215,43 @@ class UrlImportDialog(QDialog): return [e["url"] for e in chosen] if chosen else [self.url()] def spotify_tracks(self) -> list: - """The chosen songs of a Spotify link, as ``SpotifyTrack``s (empty - for any other link): the ticked ones, or the link's one song.""" + """The songs of a Spotify/Apple link to download, as + ``SpotifyTrack``s (empty for any other link): the ticked ones, or + the link's one song unless the library has it.""" if self._kind not in _CATALOGS: return [] - entries = self.chosen_entries() or ( - [self._single] if self._single else []) + if self._picking: + entries = self.chosen_entries() + else: + entries = ([self._single] if self._single + and not self._single.get("owned") else []) return [e["spotify"] for e in entries if e.get("spotify")] + def link_rows(self) -> list[dict] | None: + """The playlist the link names, in its order, as it should come out + here: ``{"key", "owned", "download"}`` per song — downloaded + (ticked), or the library's own copy (``owned``, a track id) for an + unticked song it already has. Unticked songs it doesn't have are + left out. None for a link that isn't a Spotify/Apple list.""" + if self._kind not in _CATALOGS: + return None + if self._picking and not self._just_song: + items = [self._list.item(i) for i in range(self._list.count())] + pairs = [(item.data(ENTRY_ROLE), + item.checkState() == Qt.CheckState.Checked) + for item in items] + elif self._single: + pairs = [(self._single, not self._single.get("owned"))] + else: + return None + rows = [] + for entry, ticked in pairs: + if ticked or entry.get("owned"): + rows.append({"key": entry["id"], + "owned": None if ticked else entry["owned"], + "download": ticked}) + return rows + def chosen_entries(self) -> list[dict]: """The ticked songs, in the list's order. Empty means "download the link itself" (one song, or a link that was never listed).""" @@ -226,11 +267,32 @@ class UrlImportDialog(QDialog): return sum(1 for i in range(self._list.count()) if self._list.item(i).checkState() == Qt.CheckState.Checked) + def _owned_unticked(self) -> int: + return sum(1 for i in range(self._list.count()) + if self._list.item(i).checkState() != Qt.CheckState.Checked + and self._list.item(i).data(ENTRY_ROLE).get("owned")) + + def _mark_owned(self, entry: dict): + """Note the library's copy of a Spotify/Apple song in the entry.""" + song = entry.get("spotify") + if song is None or self._library_tracks is None: + return + if self._matcher is None: + self._matcher = LibraryMatcher(list(self._library_tracks())) + hit = self._matcher.find(song.artist, song.title, song.duration) + if hit is not None: + entry["owned"] = hit.track_id + def _update_ok(self, *_): if self._picking: n = self._checked_count() - self._ok.setText(f"Import {n} Song{'' if n == 1 else 's'}") - self._ok.setEnabled(n > 0 and not ( + owned = self._owned_unticked() + if n or not owned: + self._ok.setText(f"Import {n} Song{'' if n == 1 else 's'}") + else: + self._ok.setText(f"Add {owned} Song{'' if owned == 1 else 's'}" + " From Library") + self._ok.setEnabled((n > 0 or owned > 0) and not ( self._make.isChecked() and not self._make_name.text().strip())) elif self._probe is not None: @@ -293,6 +355,7 @@ class UrlImportDialog(QDialog): if entry.get("id") in self._seen: return self._seen.add(entry.get("id")) + self._mark_owned(entry) self._entries.append(entry) if len(self._entries) == 1: return # one song is not a playlist (yet) @@ -331,13 +394,16 @@ class UrlImportDialog(QDialog): def _add_row(self, entry: dict): title = entry.get("title") or entry.get("id") or "(untitled)" length = format_duration(entry.get("duration")) - item = QListWidgetItem(f"{title} {length}" if length else title) + text = f"{title} {length}" if length else title + if entry.get("owned"): + text += " · already in your library" + item = QListWidgetItem(text) item.setData(ENTRY_ROLE, entry) item.setFlags(item.flags() | Qt.ItemFlag.ItemIsUserCheckable) if self._kind == "song_in_list": checked = entry.get("id") == self._linked else: - checked = True + checked = not entry.get("owned") self._list.blockSignals(True) item.setCheckState(Qt.CheckState.Checked if checked else Qt.CheckState.Unchecked) @@ -348,10 +414,16 @@ class UrlImportDialog(QDialog): def _count_text(self, listing: bool) -> str: n = len(self._entries) if self._kind in _CATALOGS: - return (f"This {_CATALOGS[self._kind][0]} link has {n} songs" + owned = sum(1 for e in self._entries if e.get("owned")) + text = (f"This {_CATALOGS[self._kind][0]} link has {n} songs" + ("…" if listing else ".") + "\nEach one is found on YouTube by its artist, title " "and length.") + if owned: + text += (f"\n{owned} {'is' if owned == 1 else 'are'} already " + "in your library, so unticked: the copies you have " + "go into the playlist in their place.") + return text text = f"This link is a playlist: {n} songs" if listing: text += " so far, still listing…" @@ -367,7 +439,8 @@ class UrlImportDialog(QDialog): self._busy.hide() if self._picking: self._status.setText(self._count_text(listing=False)) - if self._checked_count() == 0 and self._list.count(): + if (self._kind == "song_in_list" and self._checked_count() == 0 + and self._list.count()): # The linked song wasn't in the list it came with. self._list.item(0).setCheckState(Qt.CheckState.Checked) self._update_ok() diff --git a/lintunes/library_match.py b/lintunes/library_match.py new file mode 100644 index 0000000..a5fc329 --- /dev/null +++ b/lintunes/library_match.py @@ -0,0 +1,79 @@ +"""Is this song already in the library? (Round 130.) + +For Import from URL's Spotify and Apple Music lists: a song the library +already has is unticked in the checklist, and the copy already here goes +into the playlists in its place, so the playlist comes out the same and +only the new songs download. + +Shazam's rule (``shazam.match_library``): the same artist and title once +"(feat. …)"/"(Remastered)" are stripped, or a title sharing 80 % of its +words with an artist in common. Plus a length check, because these lists +carry exact lengths: a library copy more than ``LENGTH_SLACK`` seconds off +is a live take or another edit, not this song. Built once per list, with an +index on title words, so a 100-song list against a 20,000-song library +doesn't compare every pair. +""" +from lintunes.shazam import key_of, toks + +LENGTH_SLACK = 15 # seconds + + +class LibraryMatcher: + def __init__(self, tracks): + self._exact: dict[tuple[str, str], list] = {} + self._entries = [] + self._by_word: dict[str, list[int]] = {} + for t in tracks: + artist, name = key_of(t.artist, t.name) + if not name: + continue + self._exact.setdefault((artist, name), []).append(t) + words = toks(t.name) + index = len(self._entries) + self._entries.append((words, toks(t.artist), t)) + for w in words: + self._by_word.setdefault(w, []).append(index) + + @staticmethod + def _seconds(track) -> float | None: + ms = getattr(track, "total_time", None) + return ms / 1000 if ms else None + + def _length_ok(self, track, duration) -> bool: + have = self._seconds(track) + return not (duration and have) or abs(have - duration) <= LENGTH_SLACK + + def _closest(self, tracks, duration): + ok = [t for t in tracks if self._length_ok(t, duration)] + if not ok: + return None + if not duration: + return ok[0] + return min(ok, key=lambda t: abs((self._seconds(t) or duration) + - duration)) + + def find(self, artist: str, title: str, duration: int | None = None): + """The library's copy of this song, or None.""" + hit = self._closest(self._exact.get(key_of(artist, title), []), + duration) + if hit is not None: + return hit + nt, at = toks(title), toks(artist) + if not nt: + return None + seen: set[int] = set() + best, best_score = None, 0.0 + for w in nt: + for index in self._by_word.get(w, ()): + if index in seen: + continue + seen.add(index) + ltok, latok, t = self._entries[index] + ts = len(nt & ltok) / len(nt | ltok) + ars = (len(at & latok) / len(at | latok) + if at and latok else 0.0) + score = ts * .7 + ars * .3 + if (ts >= 0.8 and (ars > 0 or not at) and score > best_score + and self._length_ok(t, duration)): + best, best_score = t, score + return best diff --git a/lintunes/playlist_art.py b/lintunes/playlist_art.py index d1dc217..bb3bcda 100644 --- a/lintunes/playlist_art.py +++ b/lintunes/playlist_art.py @@ -1,8 +1,9 @@ """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. +made from one of their links in Import from URL keeps it. The sidebar art panel +shows it while nothing is playing and that playlist is shown +(``SidebarArt.set_playlist_art``). One file per playlist, ``/playlist_art/.jpg`` (or ``.png``), so it rides the Syncthing share with the playlists but stays out @@ -82,14 +83,17 @@ def download(url: str) -> bytes: return data -def fetch_in_background(url: str, data_dir: Path, pid: str): +def fetch_in_background(url: str, data_dir: Path, pid: str, saved=None): """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.""" + thread, then call ``saved(pid)`` *on that thread* (a Qt signal's emit + is the safe thing to pass). 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) + if saved is not None: + saved(pid) 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/tests/test_round109.py b/tests/test_round109.py index 51e6990..7fcd307 100644 --- a/tests/test_round109.py +++ b/tests/test_round109.py @@ -172,6 +172,9 @@ def _import(window, qapp, monkeypatch, ids, name="Road Trip", cover=""): def new_playlist_cover(self): return cover + + def link_rows(self): + return None def chosen_entries(self): return chosen def spotify_tracks(self): diff --git a/tests/test_round130.py b/tests/test_round130.py index 5bd5ffa..db2972e 100644 --- a/tests/test_round130.py +++ b/tests/test_round130.py @@ -290,7 +290,10 @@ def test_title_beside_artist_over_album_when_there_is_room(qapp): assert (text.artist.text(), text.album.text()) == ("Donald Fagen", "Kamakiriad") - text.resize(text.title.fontMetrics().horizontalAdvance( + from PyQt6.QtGui import QFontMetrics + big = text.title.font().pixelSize() + assert big > QFontMetrics(text._title_font).height() # it grew + text.resize(QFontMetrics(text._title_font).horizontalAdvance( "Tomorrow's Girls") + 20, 50) # too narrow: the stack assert not text.side and text.album.isHidden() assert text.artist.text().startswith("Donald Fagen") # maybe elided @@ -315,3 +318,122 @@ def test_fixed_lines_and_a_bare_title_always_stack(qapp): assert not text.side and text.artist.text() == "" text.set_song("Song", "", "Album only") assert text.side and not text.album.isHidden() and text.artist.isHidden() + + +# -------------------------------------------------------------------------- +# F. songs the library already has: unticked, but still in the playlist + +from lintunes.library_match import LibraryMatcher # noqa: E402 +from lintunes.models.track import Track # noqa: E402 + + +def _t(tid, artist, name, seconds=200): + return Track(track_id=tid, artist=artist, name=name, + total_time=seconds * 1000) + + +def test_the_matcher_finds_the_same_song_and_not_another_take(): + m = LibraryMatcher([ + _t(1, "Donald Fagen", "Tomorrow's Girls (Remastered)", 378), + _t(2, "Tate McRae", "Housewife", 209), + _t(3, "Some Band", "Song", 200), + _t(4, "Some Band", "Song", 320), + ]) + assert m.find("Donald Fagen", "Tomorrow's Girls", 378).track_id == 1 + # Apple's "A & B" artist still shares a word with the library's. + assert m.find("Tate McRae & Julia Michaels", "Housewife", + 209).track_id == 2 + assert m.find("Some Band", "Song", 318).track_id == 4 # closest length + assert m.find("Some Band", "Song", 260) is None # neither take + assert m.find("Other Band", "Housewife", 209) is None + assert m.find("Donald Fagen", "Tomorrow's Girls", None).track_id == 1 + + +def test_owned_songs_are_unticked_and_still_listed_in_order(qapp, canned): + owned = [_t(7, "Donald Fagen", "Tomorrow's Girls", 378)] + qapp.clipboard().setText(PLAYLIST_URL) + dialog = UrlImportDialog(None, library_tracks=lambda: owned) + dialog._on_import() + _pump(qapp, lambda: dialog._probe is None) + first, second = dialog._list.item(0), dialog._list.item(1) + assert "already in your library" in first.text() + assert first.checkState() == first.checkState().Unchecked + assert second.checkState() == second.checkState().Checked + assert "1 is already in your library" in dialog._status.text() + assert dialog._ok.text() == "Import 1 Song" + dialog._make.setChecked(True) + dialog._on_import() + assert [t.title for t in dialog.spotify_tracks()] == ["Zou bisou bisou"] + assert dialog.link_rows() == [ + {"key": "617854252", "owned": 7, "download": False}, + {"key": "1452872926", "owned": None, "download": True}] + + +def test_all_owned_offers_to_add_them(qapp, canned): + owned = [_t(7, "Donald Fagen", "Tomorrow's Girls", 378), + _t(8, "Gillian Hills", "Zou bisou bisou", 136)] + qapp.clipboard().setText(PLAYLIST_URL) + dialog = UrlImportDialog(None, library_tracks=lambda: owned) + dialog._on_import() + _pump(qapp, lambda: dialog._probe is None) + assert dialog._ok.text() == "Add 2 Songs From Library" + assert dialog._ok.isEnabled() + + +def test_the_playlist_comes_out_in_the_links_order(window, qapp): + """Owned songs go in as soon as everything before them is placed; a + download holds back what follows it; a failed one is skipped.""" + manager = window._manager + for tid, name in ((1, "Have A"), (2, "Have B"), (3, "Got C"), + (4, "Got E")): + manager.add_track(_t(tid, "X", name)) + window._url_target = None + window._url_inserted = 0 + window._url_new_name, window._url_new_pid = "From Apple", "" + window._url_new_cover = "" + window._url_rows = [ + {"key": "a", "owned": 1, "download": False}, + {"key": "c", "owned": None, "download": True}, + {"key": "b", "owned": 2, "download": False}, + {"key": "d", "owned": None, "download": True}, # will fail + {"key": "e", "owned": None, "download": True}, + ] + window._url_placed = 0 + window._place_url_rows() + [playlist] = _named(manager, "From Apple") + assert playlist.track_ids == [1] # c holds the rest back + window._url_row_done("e", 4) # lands early: waits + assert playlist.track_ids == [1] + window._url_row_done("c", 3) + assert playlist.track_ids == [1, 3, 2] # d still downloading + window._on_url_item_failed("d") + assert playlist.track_ids == [1, 3, 2, 4] + + +# -------------------------------------------------------------------------- +# G. the playlist's cover in the art panel while nothing plays + +def test_the_shown_playlists_cover_shows_while_nothing_plays(window, qapp, + tmp_path): + from PyQt6.QtGui import QColor, QImage + manager = window._manager + playlist = manager.create_playlist("Covered") + image = QImage(8, 8, QImage.Format.Format_RGB32) + image.fill(QColor("red")) + png = tmp_path / "c.png" + image.save(str(png)) + playlist_art.save(manager.data_dir, playlist.persistent_id, + png.read_bytes()) + art = window._sidebar.art + window._show_playlist(playlist.persistent_id) + assert art.showing_playlist_art() and art.has_art() + assert art._title() == "Covered" + + manager.add_track(_t(9, "X", "Playing")) + art.set_track(manager.library.tracks[9]) # a song: its art wins + assert not art.showing_playlist_art() + art.set_track(None) + assert art.showing_playlist_art() + + window._show_library() # no playlist shown + assert not art.showing_playlist_art() and not art.has_art() diff --git a/tests/test_round49.py b/tests/test_round49.py index 471c658..2c55640 100644 --- a/tests/test_round49.py +++ b/tests/test_round49.py @@ -352,6 +352,9 @@ class TestWindow: def new_playlist_cover(self): return "" + + def link_rows(self): + return None monkeypatch.setattr(mw, "UrlImportDialog", _Dialog) window._show_playlist("a") diff --git a/tests/test_round75.py b/tests/test_round75.py index 666caa8..c7cd008 100644 --- a/tests/test_round75.py +++ b/tests/test_round75.py @@ -368,6 +368,9 @@ def test_only_the_chosen_songs_download(window, qapp, fake, mp3_file, def new_playlist_cover(self): return "" + + def link_rows(self): + return None def chosen_entries(self): return chosen def spotify_tracks(self): @@ -419,6 +422,9 @@ def test_one_song_gets_no_progress_window(window, qapp, fake, mp3_file, def new_playlist_cover(self): return "" + + def link_rows(self): + return None def chosen_entries(self): return [] def spotify_tracks(self): diff --git a/tests/test_round76.py b/tests/test_round76.py index 5ecfb43..12a244e 100644 --- a/tests/test_round76.py +++ b/tests/test_round76.py @@ -352,6 +352,9 @@ def test_spotify_songs_import_tagged_and_go_to_identify(window, qapp, fake, def new_playlist_cover(self): return "" + + def link_rows(self): + return None def chosen_entries(self): return chosen def spotify_tracks(self):