From 29641582812521cabea57bc308c9a2dcc2577d0d Mon Sep 17 00:00:00 2001 From: trav Date: Tue, 17 Nov 2026 22:47:25 -0800 Subject: [PATCH] v0.98.0: playlist Get Info (right-click): created, songs changed, last played on any machine, the link it was imported from, and a cover any playlist can have --- CLAUDE.md | 11 ++ lintunes/__init__.py | 2 +- lintunes/gui/main_window.py | 59 +++++++++- lintunes/gui/playlist_info_dialog.py | 167 +++++++++++++++++++++++++++ lintunes/gui/sidebar.py | 6 +- lintunes/library_manager.py | 28 ++++- lintunes/models/playlist.py | 11 ++ lintunes/playlist_art.py | 10 +- lintunes/storage/playlist_plays.py | 82 +++++++++++++ tests/test_round109.py | 3 + tests/test_round130.py | 88 ++++++++++++++ tests/test_round76.py | 3 + 12 files changed, 465 insertions(+), 5 deletions(-) create mode 100644 lintunes/gui/playlist_info_dialog.py create mode 100644 lintunes/storage/playlist_plays.py diff --git a/CLAUDE.md b/CLAUDE.md index de6979b..0114877 100644 --- a/CLAUDE.md +++ b/CLAUDE.md @@ -868,6 +868,17 @@ persistence) → GUI (Qt widgets that read the manager and connect to its signal 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. + **Playlist Get Info** (sidebar right-click › Get Info, + `gui/playlist_info_dialog.py`, passive; `MainWindow._playlist_info` + applies rename + cover): name, kind, songs/length, `Playlist.date_created` + (set by every create_* since Round 130; older/iTunes playlists show —), + `date_modified`, last played and `source_url` (the link a URL import made + it from). Last played is **never in the playlist JSON** (a write per song + from both machines = Round 42's conflict): `storage/playlist_plays.py` + keeps `playlist_plays/.json` per machine (owner-only writer, + ≤ one write a minute per playlist), stamped when a song starts in a + `playlist:` context; the newest stamp across machines wins. Any + playlist's cover can be set/removed there (non-JPEG/PNG re-encoded PNG). **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 diff --git a/lintunes/__init__.py b/lintunes/__init__.py index 53626f6..c412ba6 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.97.0" +__version__ = "0.98.0" diff --git a/lintunes/gui/main_window.py b/lintunes/gui/main_window.py index 718cd34..d5f1154 100644 --- a/lintunes/gui/main_window.py +++ b/lintunes/gui/main_window.py @@ -52,6 +52,7 @@ from lintunes.gui.url_import_progress import UrlImportProgress from lintunes.gui.shazam_import import ShazamImportWindow, ShazamPreviewDialog from lintunes.gui import web_upload_progress as web_progress from lintunes.gui.info_dialog import InfoDialog +from lintunes.gui.playlist_info_dialog import PlaylistInfoDialog from lintunes.gui.music_folder_dialog import MusicFolderDialog from lintunes.gui.preferences_dialog import PreferencesDialog from lintunes.gui.track_table import format_total_time @@ -115,6 +116,23 @@ class _ResetRelay(QObject): _CURRENT_TARGET = object() +def _as_jpeg_or_png(data: bytes) -> bytes: + """A cover as playlist_art keeps it: JPEG or PNG as given, anything Qt + can read (WebP, GIF, BMP…) re-encoded as PNG.""" + if playlist_art.image_suffix(data): + return data + from PyQt6.QtCore import QBuffer, QByteArray, QIODevice + from PyQt6.QtGui import QImage + image = QImage() + if not image.loadFromData(data): + raise ValueError("not an image") + out = QByteArray() + buffer = QBuffer(out) + buffer.open(QIODevice.OpenModeFlag.WriteOnly) + image.save(buffer, "PNG") + return bytes(out) + + class MainWindow(QMainWindow): # A playlist's cover finished downloading (emitted off the GUI thread). _playlist_art_saved = pyqtSignal(str) @@ -310,6 +328,7 @@ class MainWindow(QMainWindow): # downloads nothing leaves no empty playlist behind). self._url_new_name = "" self._url_new_cover = "" + self._url_source = "" self._url_new_pid = "" self._url_rows = None # a Spotify/Apple list, in order self._url_owned = 0 @@ -353,6 +372,7 @@ class MainWindow(QMainWindow): self._sidebar.playlist_selected.connect(self._show_playlist) self._sidebar.tree.export_requested.connect(self._export_playlist) self._sidebar.tree.dj_prepare_requested.connect(self._prepare_playlist_for_dj) + self._sidebar.tree.info_requested.connect(self._playlist_info) self._sidebar.art.download_art_requested.connect( lambda tid: self._download_album_art([tid])) self._content.currentChanged.connect(self._update_totals) @@ -1571,6 +1591,38 @@ class MainWindow(QMainWindow): self._update_now_playing_icon() self._update_playlist_art() + def _playlist_info(self, pid: str): + """The playlist's Get Info; OK renames it and sets its cover.""" + playlist = self._manager.library.playlists.get(pid) + if playlist is None: + return + data_dir = self._manager.data_dir + path = playlist_art.find(data_dir, pid) + try: + art = path.read_bytes() if path is not None else None + except OSError: + art = None + tracks = [self._manager.library.tracks[t] for t in playlist.track_ids + if t in self._manager.library.tracks] + dialog = PlaylistInfoDialog( + playlist, tracks, art=art, + last_played=self._manager.playlist_last_played(pid), parent=self) + if not dialog.exec(): + return + if dialog.new_name(): + self._manager.rename_playlist(pid, dialog.new_name()) + change = dialog.art_change() + if change is not None: + try: + if change: + playlist_art.save(data_dir, pid, _as_jpeg_or_png(change)) + else: + playlist_art.remove(data_dir, pid) + except (OSError, ValueError) as e: + QMessageBox.warning(self, "Playlist Art", + f"Couldn't save the cover:\n\n{e}") + 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).""" @@ -1979,6 +2031,7 @@ class MainWindow(QMainWindow): self._url_inserted = 0 self._url_new_name = dialog.new_playlist_name() self._url_new_cover = dialog.new_playlist_cover() + self._url_source = dialog.url() self._url_new_pid = "" self._url_imported = 0 self._url_identify = True @@ -2163,7 +2216,8 @@ class MainWindow(QMainWindow): if self._url_new_pid not in self._manager.library.playlists: if not self._url_new_name: return # it was made, then deleted mid-import - playlist = self._manager.create_playlist(self._url_new_name) + playlist = self._manager.create_playlist( + self._url_new_name, source_url=self._url_source) self._url_new_pid = playlist.persistent_id self._url_new_name = "" if self._url_new_cover: # shown by the art panel @@ -3301,6 +3355,9 @@ class MainWindow(QMainWindow): else: self._listen_context = self._now_playing_context self.setWindowTitle(f"{track.name} — {track.artist} · LinTunes") + if self._now_playing_context.startswith("playlist:"): + self._manager.record_playlist_play( + self._now_playing_context.split(":", 1)[1]) self._update_now_playing_icon() def _on_listen_ended(self, key, track, started, heard_ms, how): diff --git a/lintunes/gui/playlist_info_dialog.py b/lintunes/gui/playlist_info_dialog.py new file mode 100644 index 0000000..d9f4ac7 --- /dev/null +++ b/lintunes/gui/playlist_info_dialog.py @@ -0,0 +1,167 @@ +"""A playlist's Get Info (Round 130; the sidebar's right-click › Get Info). + +What it shows: the name (editable), what kind of playlist it is, its songs +and their total length, when LinTunes made it (``Playlist.date_created`` — +playlists from before Round 130 and from the iTunes import don't know), when +its songs last changed (``date_modified``), when a song was last started +from it on any machine (``storage/playlist_plays.py``), and the link it was +imported from (``source_url``). And its cover, which any playlist can have: +paste, drop or choose an image, or remove it. + +Passive, like the song Get Info: nothing is written until OK, and then by +the caller (``MainWindow._playlist_info``), which reads ``new_name()`` and +``art_change()``. +""" +from datetime import datetime + +from PyQt6.QtCore import Qt, QUrl +from PyQt6.QtGui import QDesktopServices +from PyQt6.QtWidgets import ( + QApplication, QDialog, QDialogButtonBox, QFormLayout, QHBoxLayout, QLabel, + QLineEdit, QPushButton, QVBoxLayout, +) + +from lintunes.gui.info_dialog import ArtSquare +from lintunes.models.playlist import PlaylistType + +ART_SIZE = 200 + +_KINDS = {PlaylistType.REGULAR: "Playlist", PlaylistType.FOLDER: "Folder", + PlaylistType.SMART: "Smart Playlist", + PlaylistType.SYSTEM: "Built-in Playlist"} + + +def when_text(stamp: str | None) -> str: + """An ISO stamp as local date and time, "—" for none.""" + if not stamp: + return "—" + try: + when = datetime.fromisoformat(stamp) + except ValueError: + return stamp + if when.tzinfo is not None: + when = when.astimezone() + return when.strftime("%-d %B %Y, %-I:%M %p") + + +def length_text(ms: int) -> str: + minutes = round(ms / 60000) + hours, minutes = divmod(minutes, 60) + if hours: + return f"{hours} hr {minutes} min" + return f"{minutes} min" + + +class PlaylistInfoDialog(QDialog): + def __init__(self, playlist, tracks, *, art: bytes | None = None, + last_played: str | None = None, parent=None): + super().__init__(parent) + self.setWindowTitle(f"{playlist.name} — Info") + self._playlist = playlist + self._art_change = None # None: unchanged; b"": removed + + layout = QVBoxLayout(self) + top = QHBoxLayout() + layout.addLayout(top) + + art_column = QVBoxLayout() + self._art = ArtSquare() + self._art.setFixedSize(ART_SIZE, ART_SIZE) + self._art.set_artwork(art, "no artwork\n\npaste or drop an image") + self._art.art_staged.connect(self._on_art_staged) + self._art.hint_changed.connect(self._show_hint) + art_column.addWidget(self._art) + buttons = QHBoxLayout() + choose = QPushButton("Choose…") + choose.clicked.connect(self._art.choose_file) + paste = QPushButton("Paste") + paste.clicked.connect(self._art.paste_from_clipboard) + self._remove = QPushButton("Remove") + self._remove.clicked.connect(self._on_remove) + self._remove.setEnabled(bool(art)) + for button in (choose, paste, self._remove): + buttons.addWidget(button) + art_column.addLayout(buttons) + self._hint = QLabel("") + self._hint.setEnabled(False) + self._hint.setWordWrap(True) + self._hint.setMaximumWidth(ART_SIZE) + art_column.addWidget(self._hint) + art_column.addStretch(1) + top.addLayout(art_column) + + form = QFormLayout() + top.addLayout(form, 1) + self._name = QLineEdit(playlist.name) + self._name.setMinimumWidth(340) + form.addRow("Name:", self._name) + form.addRow("Kind:", self._label(_KINDS.get(playlist.playlist_type, + "Playlist"))) + if playlist.playlist_type != PlaylistType.FOLDER: + total = sum(t.total_time or 0 for t in tracks) + n = len(tracks) + form.addRow("Songs:", self._label( + f"{n} song{'' if n == 1 else 's'}" + + (f", {length_text(total)}" if total else ""))) + form.addRow("Created:", self._label(when_text(playlist.date_created))) + form.addRow("Songs changed:", + self._label(when_text(playlist.date_modified))) + form.addRow("Last played:", self._label(when_text(last_played))) + source = playlist.source_url + if source: + row = QHBoxLayout() + self._source = QLineEdit(source) + self._source.setReadOnly(True) + self._source.setCursorPosition(0) + copy = QPushButton("Copy") + copy.clicked.connect( + lambda: QApplication.clipboard().setText(source)) + open_link = QPushButton("Open") + open_link.clicked.connect( + lambda: QDesktopServices.openUrl(QUrl(source))) + row.addWidget(self._source, 1) + row.addWidget(copy) + row.addWidget(open_link) + form.addRow("Imported from:", row) + else: + form.addRow("Imported from:", self._label("—")) + self._source_label = source + + box = QDialogButtonBox(QDialogButtonBox.StandardButton.Ok + | QDialogButtonBox.StandardButton.Cancel) + box.accepted.connect(self.accept) + box.rejected.connect(self.reject) + layout.addWidget(box) + + @staticmethod + def _label(text: str) -> QLabel: + label = QLabel(text) + label.setTextInteractionFlags( + Qt.TextInteractionFlag.TextSelectableByMouse + | Qt.TextInteractionFlag.LinksAccessibleByMouse) + return label + + def _show_hint(self, text: str): + self._hint.setText(text) + + def _on_art_staged(self, data: bytes, _mime: str): + self._art_change = data + self._remove.setEnabled(True) + + def _on_remove(self): + self._art_change = b"" + self._art.set_artwork(None, "no artwork\n\npaste or drop an image") + self._remove.setEnabled(False) + self._hint.setText("The cover goes when you click OK") + + # ---- what the caller reads ---- + + def new_name(self) -> str: + """The name to rename to, or "" to leave it.""" + name = self._name.text().strip() + return name if name and name != self._playlist.name else "" + + def art_change(self) -> bytes | None: + """None: leave the cover; b"": remove it; else the new image.""" + return self._art_change + diff --git a/lintunes/gui/sidebar.py b/lintunes/gui/sidebar.py index 8312233..e3f19cf 100644 --- a/lintunes/gui/sidebar.py +++ b/lintunes/gui/sidebar.py @@ -552,6 +552,7 @@ class PlaylistTree(QTreeWidget): playlist_selected = pyqtSignal(str) # persistent_id export_requested = pyqtSignal(str) # persistent_id dj_prepare_requested = pyqtSignal(str) # persistent_id + info_requested = pyqtSignal(str) # persistent_id: Get Info # A friend's playlist I follow (key "cassette::"). followed_selected = pyqtSignal(str) unfollow_requested = pyqtSignal(str) @@ -939,9 +940,10 @@ class PlaylistTree(QTreeWidget): new_playlist = menu.addAction("New Playlist") new_smart = menu.addAction("New Smart Playlist") new_folder = menu.addAction("New Playlist Folder") - rename = delete = edit_smart = export = dj_prepare = None + rename = delete = edit_smart = export = dj_prepare = info = None if kind in ("playlist", "folder", "smart"): menu.addSeparator() + info = menu.addAction("Get Info") if kind == "smart": edit_smart = menu.addAction("Edit Smart Playlist…") rename = menu.addAction("Rename") @@ -962,6 +964,8 @@ class PlaylistTree(QTreeWidget): self.edit_smart_playlist(pid) elif chosen is new_folder: self.create_folder_interactive(parent_pid) + elif info is not None and chosen is info: + self.info_requested.emit(pid) elif export is not None and chosen is export: self.export_requested.emit(pid) elif dj_prepare is not None and chosen is dj_prepare: diff --git a/lintunes/library_manager.py b/lintunes/library_manager.py index ae3679a..242c687 100644 --- a/lintunes/library_manager.py +++ b/lintunes/library_manager.py @@ -124,12 +124,17 @@ class LibraryManager(QObject): # ---- playlist structure ---- - def create_playlist(self, name: str, parent_pid: str = "") -> Playlist: + def create_playlist(self, name: str, parent_pid: str = "", + source_url: str = "") -> Playlist: + """``source_url``: the link it was imported from (Get Info shows + it).""" playlist = Playlist( name=name, persistent_id=self.new_persistent_id(), parent_persistent_id=parent_pid, playlist_type=PlaylistType.REGULAR, + date_created=_utc_now_iso(), + source_url=source_url, ) self._insert_playlists([playlist]) self.undo_stack.push(Command( @@ -144,6 +149,7 @@ class LibraryManager(QObject): persistent_id=self.new_persistent_id(), parent_persistent_id=parent_pid, playlist_type=PlaylistType.FOLDER, + date_created=_utc_now_iso(), ) self._insert_playlists([folder]) self.undo_stack.push(Command( @@ -169,6 +175,7 @@ class LibraryManager(QObject): parent_persistent_id=parent_pid, playlist_type=PlaylistType.SMART, smart_criteria=criteria, + date_created=_utc_now_iso(), ) self._insert_playlists([playlist]) self.recompute_smart_playlist(playlist.persistent_id, force=True) @@ -198,6 +205,25 @@ class LibraryManager(QObject): self.recompute_smart_playlist(pid, force=True) self.playlists_changed.emit() + # ---- when playlists were played (playlist Get Info) ---- + + @property + def playlist_plays(self): + if getattr(self, "_playlist_plays", None) is None: + from lintunes.storage.playlist_plays import PlaylistPlays + self._playlist_plays = PlaylistPlays(self.data_dir, + self.play_journal.machine) + return self._playlist_plays + + def record_playlist_play(self, pid: str): + """A song started from ``pid``: stamp it in this machine's own + file (never the playlist's JSON — see playlist_plays.py).""" + if pid in self.library.playlists: + self.playlist_plays.record(pid) + + def playlist_last_played(self, pid: str) -> str | None: + return self.playlist_plays.last_played(pid) + def rename_playlist(self, pid: str, name: str): playlist = self.library.playlists.get(pid) if playlist and name and playlist.name != name: diff --git a/lintunes/models/playlist.py b/lintunes/models/playlist.py index 47db18a..f8d03bc 100644 --- a/lintunes/models/playlist.py +++ b/lintunes/models/playlist.py @@ -66,6 +66,11 @@ class Playlist: # retention window. Without it a merge is a union and a song removed on one # machine comes back from the other forever; see lintunes/tombstones.py. track_events: dict = field(default_factory=dict) + # Round 130 (playlist Get Info): when LinTunes made it (absent on older + # and imported playlists), and the link it was imported from, if any. + # Both are set once, at creation, so they can't conflict. + date_created: Optional[str] = None + source_url: str = "" # Set only for SMART playlists. Membership (track_ids) is derived from this # by the LibraryManager; for imported playlists track_ids also doubles as a # snapshot fallback when the criteria couldn't be fully parsed. @@ -103,6 +108,10 @@ class Playlist: d["parent_persistent_id"] = self.parent_persistent_id if self.date_modified: d["date_modified"] = self.date_modified + if self.date_created: + d["date_created"] = self.date_created + if self.source_url: + d["source_url"] = self.source_url if self.track_events: # JSON object keys are strings; track ids are ints everywhere else. d["track_events"] = {str(tid): event @@ -126,6 +135,8 @@ class Playlist: settings=PlaylistSettings.from_dict(d.get("settings", {})), is_system=d.get("is_system", False), date_modified=d.get("date_modified"), + date_created=d.get("date_created"), + source_url=d.get("source_url") or "", track_events={int(tid): list(event) for tid, event in (d.get("track_events") or {}).items()}, smart_criteria=smart_criteria, diff --git a/lintunes/playlist_art.py b/lintunes/playlist_art.py index bb3bcda..2b2c2fc 100644 --- a/lintunes/playlist_art.py +++ b/lintunes/playlist_art.py @@ -1,7 +1,8 @@ """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. The sidebar art panel +made from one of their links in Import from URL keeps it. Any playlist's can +be set or removed in its Get Info (``gui/playlist_info_dialog.py``). The sidebar art panel shows it while nothing is playing and that playlist is shown (``SidebarArt.set_playlist_art``). @@ -71,6 +72,13 @@ def save(data_dir: Path, pid: str, data: bytes) -> Path: return path +def remove(data_dir: Path, pid: str): + """Take the playlist's cover away (whatever its format).""" + folder = Path(data_dir) / DIRNAME + for suffix in _SUFFIXES: + (folder / f"{pid}{suffix}").unlink(missing_ok=True) + + def download(url: str) -> bytes: resp = requests.get(url, headers={"User-Agent": USER_AGENT}, timeout=TIMEOUT, stream=True) diff --git a/lintunes/storage/playlist_plays.py b/lintunes/storage/playlist_plays.py new file mode 100644 index 0000000..994125b --- /dev/null +++ b/lintunes/storage/playlist_plays.py @@ -0,0 +1,82 @@ +"""When each playlist was last played (Round 130, playlist Get Info). + +Not in the playlist's JSON: that file would change on every song from both +machines, the conflict Round 42 took away from live smart playlists. So the +play journals' rule (``play_journal.py``): each machine keeps its own +``/playlist_plays/.json`` (``{pid: ISO time}``), only +it ever writes that file, and "last played" is the newest stamp across all +of them. "Played" means a song started from that playlist. + +A stamp is written at most once a minute per playlist, so a skip through +twenty songs is one write. +""" +import json +import logging +import os +from datetime import datetime, timedelta, timezone +from pathlib import Path + +log = logging.getLogger(__name__) + +DIRNAME = "playlist_plays" +MIN_GAP = timedelta(minutes=1) + + +def _now_iso() -> str: + return datetime.now(timezone.utc).isoformat(timespec="seconds") + + +def _parse(stamp): + try: + when = datetime.fromisoformat(stamp) + except (TypeError, ValueError): + return None + return when if when.tzinfo else when.replace(tzinfo=timezone.utc) + + +class PlaylistPlays: + def __init__(self, data_dir: Path, machine: str): + self.folder = Path(data_dir) / DIRNAME + self.path = self.folder / f"{machine}.json" + self._mine = self._read(self.path) + + @staticmethod + def _read(path: Path) -> dict: + try: + data = json.loads(path.read_text(encoding="utf-8")) + except (OSError, ValueError): + return {} + return data if isinstance(data, dict) else {} + + def record(self, pid: str, when: str | None = None) -> bool: + """This machine played ``pid`` now. True when it was written.""" + when = when or _now_iso() + new, old = _parse(when), _parse(self._mine.get(pid)) + if new is None or (old is not None and new - old < MIN_GAP): + return False + self._mine[pid] = when + try: + self.folder.mkdir(parents=True, exist_ok=True) + tmp = self.path.with_name(self.path.name + ".tmp") + tmp.write_text(json.dumps(self._mine, indent=1, sort_keys=True), + encoding="utf-8") + os.replace(tmp, self.path) + except OSError as e: + log.warning("couldn't save playlist plays: %s", e) + return False + return True + + def last_played(self, pid: str) -> str | None: + """The newest stamp for ``pid`` across every machine, or None.""" + best, best_at = None, None + paths = [self.path] + try: + paths += [p for p in self.folder.glob("*.json") if p != self.path] + except OSError: + pass + for path in paths: + data = self._mine if path == self.path else self._read(path) + when = _parse(data.get(pid)) + if when is not None and (best_at is None or when > best_at): + best, best_at = data.get(pid), when + return best diff --git a/tests/test_round109.py b/tests/test_round109.py index 7fcd307..4650ab5 100644 --- a/tests/test_round109.py +++ b/tests/test_round109.py @@ -175,6 +175,9 @@ def _import(window, qapp, monkeypatch, ids, name="Road Trip", cover=""): def link_rows(self): return None + + def url(self): + return "https://example.com/list" def chosen_entries(self): return chosen def spotify_tracks(self): diff --git a/tests/test_round130.py b/tests/test_round130.py index 52703c0..85ab339 100644 --- a/tests/test_round130.py +++ b/tests/test_round130.py @@ -498,3 +498,91 @@ def test_a_missing_file_with_no_nfc_twin_stays_missing(tmp_path, qapp): manager.add_track(track) assert not manager.repair_location(track) assert track.location == str(tmp_path / "gone.mp3") + + +# -------------------------------------------------------------------------- +# I. playlist Get Info: created, last played, imported from, cover + +from lintunes.models.playlist import Playlist # noqa: E402 +from lintunes.storage.playlist_plays import PlaylistPlays # noqa: E402 + + +def test_created_and_source_round_trip_and_are_set_on_creation(tmp_path, + qapp): + p = Playlist(name="P", persistent_id="AB", date_created="2026-11-17T00:00:00+00:00", + source_url="https://music.apple.com/x") + back = Playlist.from_dict(p.to_dict()) + assert (back.date_created, back.source_url) == (p.date_created, + p.source_url) + assert "source_url" not in Playlist(name="Q").to_dict() # nothing extra + manager = _manager(tmp_path) + made = manager.create_playlist("New", source_url="https://x/y") + assert made.date_created and made.source_url == "https://x/y" + assert manager.create_folder("F").date_created + + +def test_last_played_is_the_newest_stamp_of_any_machine(tmp_path): + mine = PlaylistPlays(tmp_path, "aaa") + other = PlaylistPlays(tmp_path, "bbb") + assert mine.record("P1", "2026-11-01T10:00:00+00:00") + assert not mine.record("P1", "2026-11-01T10:00:30+00:00") # < a minute + assert other.record("P1", "2026-11-02T09:00:00+00:00") + assert mine.last_played("P1") == "2026-11-02T09:00:00+00:00" + assert mine.last_played("P2") is None + # Each machine writes only its own file. + assert sorted(p.name for p in (tmp_path / "playlist_plays").iterdir()) \ + == ["aaa.json", "bbb.json"] + + +def test_playing_from_a_playlist_stamps_it(window, qapp): + manager = window._manager + playlist = manager.create_playlist("Played") + manager.add_track(_t(5, "X", "Song")) + window._now_playing_context = f"playlist:{playlist.persistent_id}" + window._on_track_changed(manager.library.tracks[5]) + assert manager.playlist_last_played(playlist.persistent_id) + assert manager.playlist_last_played("nope") is None + + +def test_the_dialog_reports_name_and_cover_changes(qapp): + from lintunes.gui.playlist_info_dialog import PlaylistInfoDialog + playlist = Playlist(name="Mix", persistent_id="AB", + source_url="https://music.apple.com/us/playlist/x/pl.1") + dialog = PlaylistInfoDialog(playlist, [_t(1, "A", "B", 200)], art=JPEG) + assert dialog.new_name() == "" and dialog.art_change() is None + dialog._name.setText("Mix 2") + dialog._on_remove() + assert dialog.new_name() == "Mix 2" and dialog.art_change() == b"" + dialog._on_art_staged(PNG, "image/png") + assert dialog.art_change() == PNG + + +def test_get_info_ok_renames_and_sets_the_cover(window, qapp, monkeypatch, + tmp_path): + from lintunes.gui import main_window as mw + from PyQt6.QtGui import QColor, QImage + manager = window._manager + playlist = manager.create_playlist("Old") + image = QImage(4, 4, QImage.Format.Format_RGB32) + image.fill(QColor("blue")) + bmp = tmp_path / "c.bmp" # not JPEG/PNG: re-encoded + image.save(str(bmp)) + + class _Dialog: + def __init__(self, *a, **kw): + pass + def exec(self): + return True + def new_name(self): + return "New Name" + def art_change(self): + return bmp.read_bytes() + monkeypatch.setattr(mw, "PlaylistInfoDialog", _Dialog) + window._playlist_info(playlist.persistent_id) + assert playlist.name == "New Name" + saved = playlist_art.find(manager.data_dir, playlist.persistent_id) + assert saved.suffix == ".png" + + _Dialog.art_change = lambda self: b"" + window._playlist_info(playlist.persistent_id) + assert playlist_art.find(manager.data_dir, playlist.persistent_id) is None diff --git a/tests/test_round76.py b/tests/test_round76.py index 12a244e..9fb6fde 100644 --- a/tests/test_round76.py +++ b/tests/test_round76.py @@ -355,6 +355,9 @@ def test_spotify_songs_import_tagged_and_go_to_identify(window, qapp, fake, def link_rows(self): return None + + def url(self): + return "https://example.com/list" def chosen_entries(self): return chosen def spotify_tracks(self):