v0.78.0: importing a playlist link can make a new playlist of the same name

Once a YouTube, SoundCloud or Spotify link turns out to be a named list,
Import from URL offers "Make a new playlist of these songs, named …"
(off unless ticked, the name editable). yt-dlp's listing now prints each
entry's playlist_title; Spotify's probe hands over the album's or
playlist's name. The playlist is made when the first song lands, so a
link that downloads nothing leaves no empty playlist, and the songs go
in in the link's order. Undoing "New Playlist" takes it all back in one
step.
This commit is contained in:
2026-10-23 01:47:41 -07:00
parent e368b8eb6e
commit 4a32baac3a
9 changed files with 327 additions and 7 deletions
+7
View File
@@ -745,6 +745,13 @@ persistence) → GUI (Qt widgets that read the manager and connect to its signal
get `gui/url_import_progress.py`, a non-modal per-song list (Hide keeps get `gui/url_import_progress.py`, a non-modal per-song list (Hide keeps
downloading; clicking the status-bar line reopens it). `LTSTART` carries downloading; clicking the status-bar line reopens it). `LTSTART` carries
the id, and `ERROR: [site] <id>: …` lines become `item_failed`. the id, and `ERROR: [site] <id>: …` lines become `item_failed`.
**A named list can become a playlist** (Round 109): the probe also
prints `LTLIST %(playlist_title|)s` (Spotify's probe emits the album's
or playlist's name), and the dialog then offers "Make a new playlist of
these songs, named [it]", off unless ticked. `MainWindow` makes the
playlist when the *first* song lands (nothing downloaded → no empty
playlist) and adds each song with `undoable=False`, so undoing "New
Playlist" is the one step that takes it all back.
**A Spotify link** (Round 76, `spotify_link.py`, ported from trav's **A Spotify link** (Round 76, `spotify_link.py`, ported from trav's
`spotify-youtube` script) can't be downloaded, but Spotify's public `spotify-youtube` script) can't be downloaded, but Spotify's public
embed page (`open.spotify.com/embed/<kind>/<id>`, a `__NEXT_DATA__` embed page (`open.spotify.com/embed/<kind>/<id>`, a `__NEXT_DATA__`
+1 -1
View File
@@ -1,3 +1,3 @@
"""LinTunes — iTunes-style music library manager and player for Linux.""" """LinTunes — iTunes-style music library manager and player for Linux."""
__version__ = "0.77.1" __version__ = "0.78.0"
+22
View File
@@ -287,6 +287,11 @@ class MainWindow(QMainWindow):
self._bpm_results: dict[int, int] = {} self._bpm_results: dict[int, int] = {}
self._url_target = None # url_import.ImportTarget, or None self._url_target = None # url_import.ImportTarget, or None
self._url_inserted = 0 # songs added to the target so far self._url_inserted = 0 # songs added to the target so far
# "Make a new playlist of these songs": its name until the first
# song lands, then the playlist's pid (made then, so a link that
# downloads nothing leaves no empty playlist behind).
self._url_new_name = ""
self._url_new_pid = ""
self._url_imported = 0 self._url_imported = 0
self._url_identify = True # False after "Stop Identifying" self._url_identify = True # False after "Stop Identifying"
self._url_note = "" self._url_note = ""
@@ -1828,6 +1833,8 @@ class MainWindow(QMainWindow):
chosen = dialog.chosen_entries() chosen = dialog.chosen_entries()
self._url_target = target if dialog.add_to_playlist() else None self._url_target = target if dialog.add_to_playlist() else None
self._url_inserted = 0 self._url_inserted = 0
self._url_new_name = dialog.new_playlist_name()
self._url_new_pid = ""
self._url_imported = 0 self._url_imported = 0
self._url_identify = True self._url_identify = True
problem = self._identify_setup_problem() problem = self._identify_setup_problem()
@@ -1921,6 +1928,8 @@ class MainWindow(QMainWindow):
imported = self.import_files([Path(path)], pid, position) imported = self.import_files([Path(path)], pid, position)
if pid: if pid:
self._url_inserted += len(imported) self._url_inserted += len(imported)
if imported and (self._url_new_name or self._url_new_pid):
self._add_to_new_url_playlist(imported)
self._url_imported += len(imported) self._url_imported += len(imported)
if self._url_progress is not None: if self._url_progress is not None:
self._url_progress.landed(bool(imported)) self._url_progress.landed(bool(imported))
@@ -1930,6 +1939,19 @@ class MainWindow(QMainWindow):
else: else:
self._enqueue_identify(imported) self._enqueue_identify(imported)
def _add_to_new_url_playlist(self, tracks):
"""Into the link's own new playlist, in the order the songs land
(the link's order). One undo step: undoing "New Playlist" takes
it away with everything in it."""
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)
self._url_new_pid = playlist.persistent_id
self._url_new_name = ""
self._manager.add_tracks_to_playlist(
self._url_new_pid, [t.track_id for t in tracks], undoable=False)
def _finish_url_import(self): def _finish_url_import(self):
if self._url_worker is not None: if self._url_worker is not None:
self._url_worker.cleanup() self._url_worker.cleanup()
+46 -1
View File
@@ -23,6 +23,11 @@ A Spotify link (Round 76) is listed the same way, from Spotify's own page
(``url_import.SpotifyProbe``): a track goes straight through, an album or (``url_import.SpotifyProbe``): a track goes straight through, an album or
playlist is a checklist with everything ticked. The caller reads the chosen playlist is a checklist with everything ticked. The caller reads the chosen
songs from ``spotify_tracks()`` and finds each one on YouTube. songs from ``spotify_tracks()`` and finds each one on YouTube.
A list that has a name (a YouTube or SoundCloud playlist, a Spotify 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.
""" """
from urllib.parse import parse_qs, urlsplit from urllib.parse import parse_qs, urlsplit
@@ -75,6 +80,7 @@ class UrlImportDialog(QDialog):
self._single = None # the one entry of a one-song link self._single = None # the one entry of a one-song link
self._seen: set[str] = set() # ids already listed (a Mix loops) self._seen: set[str] = set() # ids already listed (a Mix loops)
self._just_song = False # "Just This Song" was pressed self._just_song = False # "Just This Song" was pressed
self._list_name = "" # what the link's list is called
self.cookies_used = None # a browser the probe needed self.cookies_used = None # a browser the probe needed
layout = QVBoxLayout(self) layout = QVBoxLayout(self)
@@ -132,6 +138,20 @@ class UrlImportDialog(QDialog):
else: else:
self._add.setChecked(True) self._add.setChecked(True)
# Shown once the link turns out to be a named list.
self._make_row = QHBoxLayout()
self._make = QCheckBox("Make a new playlist of these songs, named")
self._make_name = QLineEdit()
self._make_name.setEnabled(False)
self._make.toggled.connect(self._make_name.setEnabled)
self._make.toggled.connect(self._update_ok)
self._make_name.textChanged.connect(self._update_ok)
self._make_row.addWidget(self._make)
self._make_row.addWidget(self._make_name, 1)
for widget in (self._make, self._make_name):
widget.hide()
layout.addLayout(self._make_row)
buttons = QDialogButtonBox(QDialogButtonBox.StandardButton.Ok buttons = QDialogButtonBox(QDialogButtonBox.StandardButton.Ok
| QDialogButtonBox.StandardButton.Cancel) | QDialogButtonBox.StandardButton.Cancel)
self._ok = buttons.button(QDialogButtonBox.StandardButton.Ok) self._ok = buttons.button(QDialogButtonBox.StandardButton.Ok)
@@ -157,6 +177,13 @@ class UrlImportDialog(QDialog):
def add_to_playlist(self) -> bool: def add_to_playlist(self) -> bool:
return self._add.isEnabled() and self._add.isChecked() return self._add.isEnabled() and self._add.isChecked()
def new_playlist_name(self) -> str:
"""The name for a new playlist of the imported songs ("" for none)."""
if (not self._picking or not self._list_name or self._just_song
or not self._make.isChecked()):
return ""
return self._make_name.text().strip()
def download_urls(self) -> list[str]: def download_urls(self) -> list[str]:
"""What to hand yt-dlp: the ticked songs' own pages, the linked song """What to hand yt-dlp: the ticked songs' own pages, the linked song
alone, or the link itself — never a list link the user didn't see.""" alone, or the link itself — never a list link the user didn't see."""
@@ -193,7 +220,9 @@ class UrlImportDialog(QDialog):
if self._picking: if self._picking:
n = self._checked_count() n = self._checked_count()
self._ok.setText(f"Import {n} Song{'' if n == 1 else 's'}") self._ok.setText(f"Import {n} Song{'' if n == 1 else 's'}")
self._ok.setEnabled(n > 0) self._ok.setEnabled(n > 0 and not (
self._make.isChecked()
and not self._make_name.text().strip()))
elif self._probe is not None: elif self._probe is not None:
self._ok.setEnabled(False) self._ok.setEnabled(False)
else: else:
@@ -215,6 +244,7 @@ class UrlImportDialog(QDialog):
self._entries = [] self._entries = []
self._seen = set() self._seen = set()
self._single = None self._single = None
self._list_name = ""
self._url.setEnabled(False) self._url.setEnabled(False)
self._just.setVisible(bool(self._linked)) self._just.setVisible(bool(self._linked))
spotify = self._kind == "spotify" spotify = self._kind == "spotify"
@@ -227,6 +257,7 @@ class UrlImportDialog(QDialog):
probe = (SpotifyProbe if spotify else PlaylistProbe)( probe = (SpotifyProbe if spotify else PlaylistProbe)(
url, cookies_browser=self._cookies) url, cookies_browser=self._cookies)
probe.entry.connect(self._on_entry) probe.entry.connect(self._on_entry)
probe.named.connect(self._on_named)
probe.finished.connect(self._on_probe_finished) probe.finished.connect(self._on_probe_finished)
probe.failed.connect(self._on_probe_failed) probe.failed.connect(self._on_probe_failed)
probe.cookies_used.connect(self._on_cookies_used) probe.cookies_used.connect(self._on_cookies_used)
@@ -259,11 +290,25 @@ class UrlImportDialog(QDialog):
self._add_row(entry) self._add_row(entry)
self._status.setText(self._count_text(listing=True)) self._status.setText(self._count_text(listing=True))
def _on_named(self, name: str):
if self.sender() is not self._probe:
return
self._list_name = name
self._make_name.setText(name)
if self._picking:
self._show_make()
def _show_make(self):
self._make.show()
self._make_name.show()
def _show_picker(self): def _show_picker(self):
self._picking = True self._picking = True
self._list.show() self._list.show()
self._all.show() self._all.show()
self._none.show() self._none.show()
if self._list_name:
self._show_make()
self.resize(max(self.width(), 560), max(self.height(), 520)) self.resize(max(self.width(), 560), max(self.height(), 520))
def _add_row(self, entry: dict): def _add_row(self, entry: dict):
+24 -5
View File
@@ -71,6 +71,9 @@ ENTRY = "LTENTRY"
# a postprocessor starting or finishing (ExtractAudio = the mp3 conversion). # a postprocessor starting or finishing (ExtractAudio = the mp3 conversion).
HIT = "LTHIT" HIT = "LTHIT"
POSTPROCESS = "LTPP" POSTPROCESS = "LTPP"
# The name of the list an ENTRY came from (empty for a lone song), printed
# beside every entry — "make a new playlist with these songs" is named by it.
LISTNAME = "LTLIST"
# What YouTube says when it wants a signed-in browser. Matched on a fragment # What YouTube says when it wants a signed-in browser. Matched on a fragment
@@ -189,6 +192,7 @@ def build_probe_command(url: str,
a different order every time it's listed.""" a different order every time it's listed."""
return [ return [
"yt-dlp", "--flat-playlist", *_cookie_args(cookies_browser), "yt-dlp", "--flat-playlist", *_cookie_args(cookies_browser),
"--print", f"{LISTNAME} %(playlist_title|)s",
"--print", "--print",
f"{ENTRY} %(id)s\t%(duration|)s\t%(webpage_url|)s\t%(title)s", f"{ENTRY} %(id)s\t%(duration|)s\t%(webpage_url|)s\t%(title)s",
"--", url, "--", url,
@@ -232,7 +236,8 @@ def parse_line(line: str):
"""One line of yt-dlp output → ("start", i, n, id, title) | """One line of yt-dlp output → ("start", i, n, id, title) |
("file", path) | ("progress", percent) | ("entry", {id, duration, url, ("file", path) | ("progress", percent) | ("entry", {id, duration, url,
title}) | ("hit", {id, duration, views, url, channel, title}) | title}) | ("hit", {id, duration, views, url, channel, title}) |
("postprocess", name, status) | None for everything else.""" ("postprocess", name, status) | ("list", name) | None for everything
else."""
line = line.rstrip("\r\n") line = line.rstrip("\r\n")
if line.startswith(START + " "): if line.startswith(START + " "):
parts = line[len(START) + 1:].split("\t", 3) parts = line[len(START) + 1:].split("\t", 3)
@@ -253,6 +258,9 @@ def parse_line(line: str):
return ("hit", {"id": parts[0], "duration": _duration(parts[1]), return ("hit", {"id": parts[0], "duration": _duration(parts[1]),
"views": _int(parts[2], 0), "url": parts[3], "views": _int(parts[2], 0), "url": parts[3],
"channel": parts[4], "title": parts[5]}) "channel": parts[4], "title": parts[5]})
if line.startswith(LISTNAME + " "):
name = line[len(LISTNAME) + 1:].strip()
return ("list", name) if name and name != "NA" else None
if line.startswith(POSTPROCESS + " "): if line.startswith(POSTPROCESS + " "):
parts = line[len(POSTPROCESS) + 1:].split() parts = line[len(POSTPROCESS) + 1:].split()
if len(parts) != 2: if len(parts) != 2:
@@ -479,17 +487,20 @@ class PlaylistProbe(_YtdlpRun):
``entry`` streams each song as yt-dlp finds it ({id, duration, url, ``entry`` streams each song as yt-dlp finds it ({id, duration, url,
title}); a long Mix takes a while to list, and the dialog fills as it title}); a long Mix takes a while to list, and the dialog fills as it
goes. ``finished`` carries how many were found (cancelled or not); goes. ``named`` carries the list's own name, once, if it has one.
``failed`` means none were. ``finished`` carries how many were found (cancelled or not); ``failed``
means none were.
""" """
entry = pyqtSignal(dict) entry = pyqtSignal(dict)
named = pyqtSignal(str)
finished = pyqtSignal(int) finished = pyqtSignal(int)
def __init__(self, url: str, parent=None, *, def __init__(self, url: str, parent=None, *,
cookies_browser: str | None = None): cookies_browser: str | None = None):
super().__init__(parent, cookies_browser=cookies_browser) super().__init__(parent, cookies_browser=cookies_browser)
self._url = url self._url = url
self._named = False
def start(self): def start(self):
if not self._busy: if not self._busy:
@@ -499,7 +510,12 @@ class PlaylistProbe(_YtdlpRun):
return build_probe_command(self._url, cookies_browser) return build_probe_command(self._url, cookies_browser)
def _on_parsed(self, parsed): def _on_parsed(self, parsed):
if parsed[0] != "entry" or self._cancel.is_set(): if self._cancel.is_set():
return False
if parsed[0] == "list" and not self._named:
self._named = True
self.named.emit(parsed[1])
if parsed[0] != "entry":
return False return False
self.entry.emit(parsed[1]) self.entry.emit(parsed[1])
return True return True
@@ -603,6 +619,7 @@ class SpotifyProbe(QObject):
``SpotifyTrack`` under ``"spotify"``. One request, no yt-dlp.""" ``SpotifyTrack`` under ``"spotify"``. One request, no yt-dlp."""
entry = pyqtSignal(dict) entry = pyqtSignal(dict)
named = pyqtSignal(str) # the album's or playlist's name
finished = pyqtSignal(int) finished = pyqtSignal(int)
failed = pyqtSignal(str) failed = pyqtSignal(str)
cookies_used = pyqtSignal(str) # never: Spotify needs no cookies cookies_used = pyqtSignal(str) # never: Spotify needs no cookies
@@ -627,11 +644,13 @@ class SpotifyProbe(QObject):
def _run(self): def _run(self):
try: try:
kind, source_id = spotify_link.spotify_source(self._url) kind, source_id = spotify_link.spotify_source(self._url)
_name, tracks = spotify_link.fetch(kind, source_id) name, tracks = spotify_link.fetch(kind, source_id)
except Exception as e: except Exception as e:
self._busy = False self._busy = False
self.failed.emit(str(e)) self.failed.emit(str(e))
return return
if kind != "track":
self.named.emit(name)
count = 0 count = 0
for track in tracks: for track in tracks:
if self._cancel.is_set(): if self._cancel.is_set():
+219
View File
@@ -0,0 +1,219 @@
"""Round 109 — importing a playlist link can make a playlist of it.
A YouTube or SoundCloud playlist, or a Spotify album or playlist, has a
name. Once the link turns out to be a list, the import dialog offers
"Make a new playlist of these songs, named [its name]" (off unless ticked,
the name editable). The playlist is made when the first song lands, so a
link that downloads nothing leaves no empty playlist, and the songs go in
in the link's order.
yt-dlp itself is never run: round 75's fake, taught to print the list name.
"""
import os
import stat
import sys
import pytest
from lintunes import spotify_link, url_import
from lintunes.gui.url_import_dialog import UrlImportDialog
from lintunes.library_manager import LibraryManager
from lintunes.models import Library
from lintunes.preferences import Preferences
from lintunes.spotify_link import SpotifyTrack
from tests.test_round75 import FAKE_YTDLP, MIX, _pump
PLAYLIST = "https://www.youtube.com/playlist?list=PLx"
# Every listed entry is preceded by the name of its list, as yt-dlp's
# "%(playlist_title|)s" prints it ("" for a lone song).
FAKE_WITH_NAME = FAKE_YTDLP.replace(
' print(f"LTENTRY {vid}',
' print("LTLIST " + os.environ.get("FAKE_LISTNAME", ""), '
'flush=True)\n print(f"LTENTRY {vid}')
@pytest.fixture
def fake(tmp_path, monkeypatch):
assert FAKE_WITH_NAME != FAKE_YTDLP
bin_dir = tmp_path / "bin"
bin_dir.mkdir()
script = bin_dir / "yt-dlp"
script.write_text(FAKE_WITH_NAME.replace("/usr/bin/env python3",
sys.executable))
script.chmod(script.stat().st_mode | stat.S_IEXEC)
monkeypatch.setenv("PATH", f"{bin_dir}{os.pathsep}{os.environ['PATH']}")
monkeypatch.setenv("FAKE_YTDLP_LOG", str(tmp_path / "argv.log"))
monkeypatch.setenv("XDG_CONFIG_HOME", str(tmp_path / "config"))
monkeypatch.setenv("FAKE_LISTNAME", "Road Trip")
def _dialog(qapp, url):
qapp.clipboard().setText(url)
return UrlImportDialog("Adds to the end of “Chill”")
# --------------------------------------------------------------------------
# A. the name, from yt-dlp and from Spotify
def test_list_name_lines():
assert url_import.parse_line("LTLIST Road Trip\n") == ("list", "Road Trip")
assert url_import.parse_line("LTLIST \n") is None # a lone song
assert url_import.parse_line("LTLIST NA\n") is None
assert "LTLIST %(playlist_title|)s" in url_import.build_probe_command(
PLAYLIST)
def test_the_probe_names_its_list_once(qapp, fake):
probe = url_import.PlaylistProbe(PLAYLIST)
names, done = [], []
probe.named.connect(names.append)
probe.finished.connect(done.append)
probe.start()
_pump(qapp, lambda: done)
assert names == ["Road Trip"]
@pytest.mark.parametrize("link, named", [
("https://open.spotify.com/album/abc", ["Fresh Album"]),
("https://open.spotify.com/track/abc", []),
])
def test_spotify_names_albums_and_playlists(qapp, monkeypatch, link, named):
monkeypatch.setattr(spotify_link, "fetch", lambda kind, sid: (
"Fresh Album", [SpotifyTrack(id="1", title="One", artist="A")]))
probe = url_import.SpotifyProbe(link)
names, done = [], []
probe.named.connect(names.append)
probe.finished.connect(done.append)
probe.start()
_pump(qapp, lambda: done)
assert names == named
# --------------------------------------------------------------------------
# B. the dialog
def test_a_named_list_offers_a_new_playlist(qapp, fake):
dialog = _dialog(qapp, PLAYLIST)
assert not dialog._make.isVisibleTo(dialog)
dialog._on_import()
_pump(qapp, lambda: dialog._probe is None)
assert dialog._make.isVisibleTo(dialog)
assert dialog._make_name.text() == "Road Trip"
assert not dialog._make.isChecked() # off unless ticked
assert dialog.new_playlist_name() == ""
dialog._make.setChecked(True)
assert dialog.new_playlist_name() == "Road Trip"
dialog._make_name.setText("")
assert not dialog._ok.isEnabled() # a playlist needs a name
dialog._make_name.setText(" Summer ")
assert dialog._ok.isEnabled()
dialog._on_import()
assert dialog.new_playlist_name() == "Summer"
def test_no_name_no_offer(qapp, fake, monkeypatch):
monkeypatch.setenv("FAKE_LISTNAME", "")
dialog = _dialog(qapp, PLAYLIST)
dialog._on_import()
_pump(qapp, lambda: dialog._probe is None)
assert dialog._picking
assert not dialog._make.isVisibleTo(dialog)
dialog._make.setChecked(True)
assert dialog.new_playlist_name() == ""
def test_just_this_song_makes_no_playlist(qapp, fake):
dialog = _dialog(qapp, MIX)
dialog._on_import()
_pump(qapp, lambda: dialog._probe is None)
dialog._make.setChecked(True)
dialog._just.click()
assert dialog.new_playlist_name() == ""
# --------------------------------------------------------------------------
# C. through the window
@pytest.fixture
def window(qapp, tmp_path, fake, monkeypatch):
from lintunes.gui.main_window import MainWindow
library = Library(music_folder=str(tmp_path / "media"))
(tmp_path / "media").mkdir()
manager = LibraryManager(library, tmp_path / "data")
win = MainWindow(manager, Preferences(tmp_path / "data"))
monkeypatch.setattr(win, "_enqueue_identify", lambda tracks: None)
monkeypatch.setattr(win, "_show_batch_review", lambda analysis: None)
yield win
if win._url_batch is not None:
win._url_batch.cancel()
win.close()
def _import(window, qapp, monkeypatch, ids, name="Road Trip"):
from lintunes.gui import main_window as mw
chosen = [{"id": i, "title": f"Song {i}",
"url": f"https://www.youtube.com/watch?v={i}"} for i in ids]
class _Dialog:
cookies_used = None
def __init__(self, *a, **kw):
pass
def exec(self):
return True
def add_to_playlist(self):
return False
def new_playlist_name(self):
return name
def chosen_entries(self):
return chosen
def spotify_tracks(self):
return []
def download_urls(self):
return [c["url"] for c in chosen]
monkeypatch.setattr(mw, "UrlImportDialog", _Dialog)
window._import_from_url()
worker = window._url_worker
_pump(qapp, lambda: worker.temp_dir is None)
def _named(manager, name):
return [p for p in manager.library.playlists.values() if p.name == name]
def test_the_new_playlist_holds_every_song_in_order(window, qapp, fake,
mp3_file, monkeypatch):
monkeypatch.setenv("FAKE_YTDLP_AUDIO", str(mp3_file))
manager = window._manager
_import(window, qapp, monkeypatch, ["ccc", "bad1", "aaa"])
[playlist] = _named(manager, "Road Trip")
titles = [manager.library.tracks[t].name for t in playlist.track_ids]
assert titles == ["Song ccc [ccc]", "Song aaa [aaa]"] # not the failed one
manager.undo_stack.undo() # one step takes it all away
assert _named(manager, "Road Trip") == []
assert len(manager.library.tracks) == 2 # the songs stay imported
def test_nothing_downloaded_makes_no_playlist(window, qapp, fake, mp3_file,
monkeypatch):
from lintunes.gui import main_window as mw
warned = []
monkeypatch.setattr(mw.QMessageBox, "warning",
lambda *a, **kw: warned.append(a))
monkeypatch.setenv("FAKE_YTDLP_AUDIO", str(mp3_file))
_import(window, qapp, monkeypatch, ["bad1", "bad2"])
_pump(qapp, lambda: warned) # "Couldn't import from that link"
assert _named(window._manager, "Road Trip") == []
def test_unticked_makes_no_playlist(window, qapp, fake, mp3_file,
monkeypatch):
monkeypatch.setenv("FAKE_YTDLP_AUDIO", str(mp3_file))
before = set(window._manager.library.playlists)
_import(window, qapp, monkeypatch, ["aaa", "bbb"], name="")
assert set(window._manager.library.playlists) == before
+2
View File
@@ -347,6 +347,8 @@ class TestWindow:
return "https://x.test/list" return "https://x.test/list"
def add_to_playlist(self): def add_to_playlist(self):
return True return True
def new_playlist_name(self):
return ""
monkeypatch.setattr(mw, "UrlImportDialog", _Dialog) monkeypatch.setattr(mw, "UrlImportDialog", _Dialog)
window._show_playlist("a") window._show_playlist("a")
+4
View File
@@ -363,6 +363,8 @@ def test_only_the_chosen_songs_download(window, qapp, fake, mp3_file,
return MIX return MIX
def add_to_playlist(self): def add_to_playlist(self):
return False return False
def new_playlist_name(self):
return ""
def chosen_entries(self): def chosen_entries(self):
return chosen return chosen
def spotify_tracks(self): def spotify_tracks(self):
@@ -409,6 +411,8 @@ def test_one_song_gets_no_progress_window(window, qapp, fake, mp3_file,
return "https://www.youtube.com/watch?v=aaa" return "https://www.youtube.com/watch?v=aaa"
def add_to_playlist(self): def add_to_playlist(self):
return False return False
def new_playlist_name(self):
return ""
def chosen_entries(self): def chosen_entries(self):
return [] return []
def spotify_tracks(self): def spotify_tracks(self):
+2
View File
@@ -347,6 +347,8 @@ def test_spotify_songs_import_tagged_and_go_to_identify(window, qapp, fake,
return True return True
def add_to_playlist(self): def add_to_playlist(self):
return False return False
def new_playlist_name(self):
return ""
def chosen_entries(self): def chosen_entries(self):
return chosen return chosen
def spotify_tracks(self): def spotify_tracks(self):