travandClaude Opus 5.5
759fa85153
- Sync Settings gets a share selector on each friend page (and on General when "Share the same selection with all friends" is on; each friend's own selection is kept, greyed, and comes back when it's turned off). - Library: a genre/artist/album column browser with a checkbox beside every artist, album and track, search, Select All / Select None and "Share whole library". Playlists: a checklist with "Share all playlists". Nothing is shared by default. - Checking an artist or album is a snapshot of its tracks; the whole library and shared playlists are live. A shared playlist's tracks are checked and locked, with a tooltip naming the playlist(s). - cassette/share.py writes the trimmed copy (library.json, playlists.json) into each friend's folder: tags yes, listening history and local paths no. Written on OK and after library edits (debounced), and only when the bytes would change. Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
246 lines
11 KiB
Python
246 lines
11 KiB
Python
"""Round 66: the share selector and the trimmed library copy a friend reads.
|
|
|
|
* Nothing is shared by default. "Share whole library" is live (new songs are
|
|
offered too); checked artists/albums store the track ids they covered then,
|
|
so a new album shows up unchecked; shared playlists are live and their
|
|
tracks are locked in the Library section with a tooltip naming them.
|
|
* Offering never sends anything — the copy only lists what may be asked for,
|
|
and keeps the tags while dropping my listening history and anything local.
|
|
* The copy is written only when its bytes would change.
|
|
"""
|
|
import json
|
|
|
|
from PyQt6.QtCore import Qt
|
|
|
|
from lintunes.cassette import share
|
|
from lintunes.cassette.state import CassetteState, Friend, Selection, out_dir
|
|
from lintunes.models import Playlist, PlaylistType, Track
|
|
from lintunes.models.library import Library
|
|
|
|
|
|
def _library():
|
|
library = Library()
|
|
rows = [
|
|
(1, "Reel One", "Analog Ghost", "Tape Hiss", "Folk"),
|
|
(2, "Reel Two", "Analog Ghost", "Tape Hiss", "Jazz"),
|
|
(3, "B-Side", "Analog Ghost", "Other Album", "Jazz"),
|
|
(4, "Étoile", "Marguerite Vaux", "Nuit Blanche", "Jazz"),
|
|
(5, "Café", "Marguerite Vaux", "Nuit Blanche", "Electronic"),
|
|
]
|
|
for tid, name, artist, album, genre in rows:
|
|
library.tracks[tid] = Track(
|
|
track_id=tid, name=name, artist=artist, album=album, genre=genre,
|
|
year=1987, total_time=180000, size=4_000_000, play_count=41,
|
|
rating=80, loved=True, comments="private note",
|
|
location=f"/music/{tid}.mp3", date_added="2020-01-01T00:00:00",
|
|
play_date_utc="2026-01-01T00:00:00")
|
|
library.playlists["P1"] = Playlist(name="Road Trip", persistent_id="P1",
|
|
track_ids=[4, 1])
|
|
library.playlists["P2"] = Playlist(name="Morning", persistent_id="P2",
|
|
track_ids=[5])
|
|
library.playlists["F"] = Playlist(name="Boxes", persistent_id="F",
|
|
playlist_type=PlaylistType.FOLDER)
|
|
library.playlists["S"] = Playlist(name="Music", persistent_id="S",
|
|
is_system=True,
|
|
playlist_type=PlaylistType.SYSTEM)
|
|
return library
|
|
|
|
|
|
# ---- what is offered ----
|
|
|
|
class TestOffered:
|
|
def test_nothing_by_default(self):
|
|
assert share.offered_ids(_library(), Selection()) == set()
|
|
|
|
def test_whole_library_is_live(self):
|
|
library = _library()
|
|
selection = Selection(all_library=True)
|
|
library.tracks[9] = Track(track_id=9, name="New")
|
|
assert 9 in share.offered_ids(library, selection)
|
|
|
|
def test_checked_tracks_plus_shared_playlists(self):
|
|
selection = Selection(track_ids={2, 99}, playlist_ids={"P1"})
|
|
assert share.offered_ids(_library(), selection) == {1, 2, 4}
|
|
|
|
def test_shared_playlist_is_live(self):
|
|
library = _library()
|
|
selection = Selection(playlist_ids={"P1"})
|
|
library.playlists["P1"].track_ids.append(3)
|
|
assert 3 in share.offered_ids(library, selection)
|
|
|
|
def test_locks_name_every_playlist(self):
|
|
library = _library()
|
|
library.playlists["P2"].track_ids.append(4)
|
|
locks = share.locks(library, Selection(all_playlists=True))
|
|
assert sorted(locks[4]) == ["Morning", "Road Trip"]
|
|
|
|
def test_folders_and_system_playlists_are_never_shared(self):
|
|
names = [p.name for p in share.shared_playlists(
|
|
_library(), Selection(all_playlists=True))]
|
|
assert names == ["Morning", "Road Trip"]
|
|
|
|
|
|
# ---- what the copy holds ----
|
|
|
|
class TestCopy:
|
|
def test_tags_yes_history_no(self):
|
|
library = _library()
|
|
entry = share.build_library(library, Selection(track_ids={1}))["tracks"][0]
|
|
assert entry["id"] == 1 and entry["name"] == "Reel One"
|
|
assert entry["artist"] == "Analog Ghost" and entry["year"] == 1987
|
|
assert entry["size"] == 4_000_000 and entry["total_time"] == 180000
|
|
for private in ("play_count", "rating", "loved", "comments", "location",
|
|
"date_added", "play_date_utc", "persistent_id"):
|
|
assert private not in entry
|
|
|
|
def test_playlists_keep_order_and_drop_unoffered(self):
|
|
library = _library()
|
|
library.playlists["P1"].track_ids.append(77) # dangling id
|
|
data = share.build_playlists(library, Selection(playlist_ids={"P1"}))
|
|
assert data["playlists"] == [{"id": "P1", "name": "Road Trip",
|
|
"smart": False, "track_ids": [4, 1]}]
|
|
|
|
def test_written_only_when_changed(self, tmp_path):
|
|
library = _library()
|
|
selection = Selection(track_ids={1})
|
|
assert share.publish_share(tmp_path, library, selection)
|
|
mtime = (tmp_path / share.LIBRARY_FILE).stat().st_mtime_ns
|
|
assert not share.publish_share(tmp_path, library, selection)
|
|
assert (tmp_path / share.LIBRARY_FILE).stat().st_mtime_ns == mtime
|
|
selection.track_ids.add(2)
|
|
assert share.publish_share(tmp_path, library, selection)
|
|
data = json.loads((tmp_path / share.LIBRARY_FILE).read_text())
|
|
assert [t["id"] for t in data["tracks"]] == [1, 2]
|
|
|
|
|
|
# ---- the service ----
|
|
|
|
class TestRepublish:
|
|
def test_each_friend_gets_their_selection(self, qapp, tmp_path):
|
|
from lintunes.cassette.service import CassetteService
|
|
library = _library()
|
|
service = CassetteService(root=tmp_path, config_loader=lambda: {})
|
|
service.set_library_provider(lambda: library)
|
|
service._state.friends["a"] = Friend(token="a", device_id="A", name="Amy",
|
|
selection=Selection(track_ids={1}))
|
|
service._state.friends["b"] = Friend(token="b", device_id="B", name="Bo",
|
|
selection=Selection(playlist_ids={"P2"}))
|
|
assert sorted(service.republish()) == ["a", "b"]
|
|
assert service.republish() == []
|
|
|
|
def ids(token):
|
|
data = json.loads((out_dir(tmp_path, token) / share.LIBRARY_FILE).read_text())
|
|
return [t["id"] for t in data["tracks"]]
|
|
assert ids("a") == [1]
|
|
assert ids("b") == [5]
|
|
|
|
service._state.share_same_for_all = True
|
|
service._state.general = Selection(track_ids={3})
|
|
service.republish()
|
|
assert ids("a") == ids("b") == [3]
|
|
|
|
|
|
# ---- the selector ----
|
|
|
|
def _selector(qapp, selection=None, library=None):
|
|
from lintunes.gui.share_selector import ShareSelector
|
|
return ShareSelector(library or _library(), selection or Selection())
|
|
|
|
|
|
def _track_items(selector):
|
|
return {selector.tracks.topLevelItem(i).data(0, Qt.ItemDataRole.UserRole):
|
|
selector.tracks.topLevelItem(i)
|
|
for i in range(selector.tracks.topLevelItemCount())}
|
|
|
|
|
|
def _row(column, text):
|
|
return column.findItems(text, Qt.MatchFlag.MatchExactly)[0]
|
|
|
|
|
|
class TestSelector:
|
|
def test_starts_empty(self, qapp):
|
|
selector = _selector(qapp)
|
|
assert all(item.checkState(0) == Qt.CheckState.Unchecked
|
|
for item in _track_items(selector).values())
|
|
|
|
def test_checking_an_artist_checks_its_tracks(self, qapp):
|
|
selection = Selection()
|
|
selector = _selector(qapp, selection)
|
|
_row(selector.artists, "Analog Ghost").setCheckState(Qt.CheckState.Checked)
|
|
assert selection.track_ids == {1, 2, 3}
|
|
assert _row(selector.albums, "Tape Hiss").checkState() == Qt.CheckState.Checked
|
|
|
|
def test_album_then_partial_artist(self, qapp):
|
|
selection = Selection()
|
|
selector = _selector(qapp, selection)
|
|
_row(selector.albums, "Tape Hiss").setCheckState(Qt.CheckState.Checked)
|
|
assert selection.track_ids == {1, 2}
|
|
assert _row(selector.artists, "Analog Ghost").checkState() == \
|
|
Qt.CheckState.PartiallyChecked
|
|
|
|
def test_genre_filter_scopes_the_artist_box(self, qapp):
|
|
selection = Selection()
|
|
selector = _selector(qapp, selection)
|
|
selector.genres.setCurrentItem(_row(selector.genres, "Jazz"))
|
|
_row(selector.artists, "Analog Ghost").setCheckState(Qt.CheckState.Checked)
|
|
assert selection.track_ids == {2, 3} # not the Folk one
|
|
|
|
def test_playlist_tracks_are_locked_with_a_tooltip(self, qapp):
|
|
selection = Selection()
|
|
selector = _selector(qapp, selection)
|
|
_row(selector.playlists, "Road Trip").setCheckState(Qt.CheckState.Checked)
|
|
assert selection.playlist_ids == {"P1"}
|
|
item = _track_items(selector)[4]
|
|
assert item.checkState(0) == Qt.CheckState.Checked
|
|
assert not item.flags() & Qt.ItemFlag.ItemIsUserCheckable
|
|
assert "Road Trip" in item.toolTip(0)
|
|
assert 4 not in selection.track_ids # locked, not chosen
|
|
|
|
def test_select_none_keeps_locked_tracks(self, qapp):
|
|
selection = Selection(track_ids={2, 3}, playlist_ids={"P1"})
|
|
selector = _selector(qapp, selection)
|
|
selector.lib_none.click()
|
|
assert selection.track_ids == set()
|
|
assert _track_items(selector)[1].checkState(0) == Qt.CheckState.Checked
|
|
|
|
def test_select_all_buttons(self, qapp):
|
|
selection = Selection()
|
|
selector = _selector(qapp, selection)
|
|
selector.lib_all.click()
|
|
selector.pl_all.click()
|
|
assert selection.track_ids == {1, 2, 3, 4, 5}
|
|
assert selection.playlist_ids == {"P1", "P2"}
|
|
|
|
def test_whole_library_greys_the_browser(self, qapp):
|
|
selection = Selection()
|
|
selector = _selector(qapp, selection)
|
|
selector.whole_library.setChecked(True)
|
|
assert selection.all_library
|
|
assert not selector._browser_host.isEnabled()
|
|
assert all(i.checkState(0) == Qt.CheckState.Checked
|
|
for i in _track_items(selector).values())
|
|
|
|
|
|
# ---- the dialog ----
|
|
|
|
class TestSameForAll:
|
|
def test_turning_it_off_restores_each_friend(self, qapp, tmp_path):
|
|
from lintunes.gui.sync_settings_dialog import SyncSettingsDialog
|
|
from tests.test_round64 import _NoProbe
|
|
state = CassetteState()
|
|
state.friends["a"] = Friend(token="a", device_id="A", name="Amy",
|
|
selection=Selection(track_ids={1}))
|
|
dialog = SyncSettingsDialog(state, tmp_path, {}, probe=_NoProbe(),
|
|
library=_library())
|
|
dialog._show_page(1)
|
|
page = dialog.friend_pages["a"]
|
|
dialog.general.same_for_all.setChecked(True)
|
|
assert dialog.general.selector is not None
|
|
assert page.using_general.isVisibleTo(dialog)
|
|
assert not page.selector.whole_library.isEnabled()
|
|
dialog.general.selector.lib_all.click()
|
|
dialog.general.same_for_all.setChecked(False)
|
|
assert dialog.state.friends["a"].selection.track_ids == {1}
|
|
assert dialog.state.general.track_ids == {1, 2, 3, 4, 5}
|
|
assert not dialog.state.share_same_for_all
|