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
This commit is contained in:
@@ -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/<machine id>.json` per machine (owner-only writer,
|
||||
≤ one write a minute per playlist), stamped when a song starts in a
|
||||
`playlist:<pid>` 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
|
||||
|
||||
@@ -1,3 +1,3 @@
|
||||
"""LinTunes — iTunes-style music library manager and player for Linux."""
|
||||
|
||||
__version__ = "0.97.0"
|
||||
__version__ = "0.98.0"
|
||||
|
||||
@@ -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):
|
||||
|
||||
@@ -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
|
||||
|
||||
@@ -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:<token>:<their pid>").
|
||||
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:
|
||||
|
||||
@@ -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:
|
||||
|
||||
@@ -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,
|
||||
|
||||
@@ -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)
|
||||
|
||||
@@ -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
|
||||
``<data_dir>/playlist_plays/<machine id>.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
|
||||
@@ -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):
|
||||
|
||||
@@ -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
|
||||
|
||||
@@ -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):
|
||||
|
||||
Reference in New Issue
Block a user