From 70d4dba7aac8ebc654cfe06ced9c2e2ffe06496d Mon Sep 17 00:00:00 2001 From: Stein Magnus Jodal Date: Tue, 20 Nov 2012 09:40:39 +0100 Subject: [PATCH 1/4] core: Remove playback.track_at_next --- docs/changes.rst | 3 +++ mopidy/core/playback.py | 11 -------- mopidy/frontends/mpris/objects.py | 4 +-- tests/backends/base/__init__.py | 3 ++- tests/backends/base/playback.py | 42 +++++++++++++++---------------- 5 files changed, 28 insertions(+), 35 deletions(-) diff --git a/docs/changes.rst b/docs/changes.rst index 5ed689a3..4bdacd78 100644 --- a/docs/changes.rst +++ b/docs/changes.rst @@ -149,6 +149,9 @@ backends: This makes it possible to support lookup of artist or album URIs which then can expand to a list of tracks. +- Remove :attr:`mopidy.core.PlaybackController.track_at_next`. Use + :attr:`mopidy.core.PlaybackController.tl_track_at_next` instead. + - Added support for connecting to the Spotify service through an HTTP or SOCKS proxy, which is supported by pyspotify >= 1.9. diff --git a/mopidy/core/playback.py b/mopidy/core/playback.py index e562a9b1..613f21ba 100644 --- a/mopidy/core/playback.py +++ b/mopidy/core/playback.py @@ -168,17 +168,6 @@ class PlaybackController(object): Not necessarily the same track as :attr:`tl_track_at_next`. """ - def get_track_at_next(self): - return self.tl_track_at_next and self.tl_track_at_next.track - - track_at_next = property(get_track_at_next) - """ - The track that will be played if calling :meth:`next()`. - - Read-only. A :class:`mopidy.models.Track` extracted from - :attr:`tl_track_at_next` for convenience. - """ - def get_tl_track_at_next(self): tl_tracks = self.core.tracklist.tl_tracks diff --git a/mopidy/frontends/mpris/objects.py b/mopidy/frontends/mpris/objects.py index 51b0d7e8..93f14a2d 100644 --- a/mopidy/frontends/mpris/objects.py +++ b/mopidy/frontends/mpris/objects.py @@ -419,8 +419,8 @@ class MprisObject(dbus.service.Object): if not self.get_CanControl(): return False return ( - self.core.playback.current_track.get() is not None or - self.core.playback.track_at_next.get() is not None) + self.core.playback.current_tl_track.get() is not None or + self.core.playback.tl_track_at_next.get() is not None) def get_CanPause(self): if not self.get_CanControl(): diff --git a/tests/backends/base/__init__.py b/tests/backends/base/__init__.py index c415ef23..477f8cc1 100644 --- a/tests/backends/base/__init__.py +++ b/tests/backends/base/__init__.py @@ -3,8 +3,9 @@ from __future__ import unicode_literals def populate_tracklist(func): def wrapper(self): + self.tl_tracks = [] for track in self.tracks: - self.core.tracklist.add(track) + self.tl_tracks.append(self.core.tracklist.add(track)) return func(self) wrapper.__name__ = func.__name__ diff --git a/tests/backends/base/playback.py b/tests/backends/base/playback.py index 94fc7759..619efbb2 100644 --- a/tests/backends/base/playback.py +++ b/tests/backends/base/playback.py @@ -234,29 +234,29 @@ class PlaybackControllerTest(object): @populate_tracklist def test_next_track_before_play(self): - self.assertEqual(self.playback.track_at_next, self.tracks[0]) + self.assertEqual(self.playback.tl_track_at_next, self.tl_tracks[0]) @populate_tracklist def test_next_track_during_play(self): self.playback.play() - self.assertEqual(self.playback.track_at_next, self.tracks[1]) + self.assertEqual(self.playback.tl_track_at_next, self.tl_tracks[1]) @populate_tracklist def test_next_track_after_previous(self): self.playback.play() self.playback.next() self.playback.previous() - self.assertEqual(self.playback.track_at_next, self.tracks[1]) + self.assertEqual(self.playback.tl_track_at_next, self.tl_tracks[1]) def test_next_track_empty_playlist(self): - self.assertEqual(self.playback.track_at_next, None) + self.assertEqual(self.playback.tl_track_at_next, None) @populate_tracklist def test_next_track_at_end_of_playlist(self): self.playback.play() for _ in self.tracklist.tl_tracks[1:]: self.playback.next() - self.assertEqual(self.playback.track_at_next, None) + self.assertEqual(self.playback.tl_track_at_next, None) @populate_tracklist def test_next_track_at_end_of_playlist_with_repeat(self): @@ -264,13 +264,13 @@ class PlaybackControllerTest(object): self.playback.play() for _ in self.tracks[1:]: self.playback.next() - self.assertEqual(self.playback.track_at_next, self.tracks[0]) + self.assertEqual(self.playback.tl_track_at_next, self.tl_tracks[0]) @populate_tracklist def test_next_track_with_random(self): random.seed(1) self.playback.random = True - self.assertEqual(self.playback.track_at_next, self.tracks[2]) + self.assertEqual(self.playback.tl_track_at_next, self.tl_tracks[2]) @populate_tracklist def test_next_with_consume(self): @@ -300,9 +300,9 @@ class PlaybackControllerTest(object): def test_next_track_with_random_after_append_playlist(self): random.seed(1) self.playback.random = True - self.assertEqual(self.playback.track_at_next, self.tracks[2]) + self.assertEqual(self.playback.tl_track_at_next, self.tl_tracks[2]) self.tracklist.append(self.tracks[:1]) - self.assertEqual(self.playback.track_at_next, self.tracks[1]) + self.assertEqual(self.playback.tl_track_at_next, self.tl_tracks[1]) @populate_tracklist def test_end_of_track(self): @@ -370,29 +370,29 @@ class PlaybackControllerTest(object): @populate_tracklist def test_end_of_track_track_before_play(self): - self.assertEqual(self.playback.track_at_next, self.tracks[0]) + self.assertEqual(self.playback.tl_track_at_next, self.tl_tracks[0]) @populate_tracklist def test_end_of_track_track_during_play(self): self.playback.play() - self.assertEqual(self.playback.track_at_next, self.tracks[1]) + self.assertEqual(self.playback.tl_track_at_next, self.tl_tracks[1]) @populate_tracklist def test_end_of_track_track_after_previous(self): self.playback.play() self.playback.on_end_of_track() self.playback.previous() - self.assertEqual(self.playback.track_at_next, self.tracks[1]) + self.assertEqual(self.playback.tl_track_at_next, self.tl_tracks[1]) def test_end_of_track_track_empty_playlist(self): - self.assertEqual(self.playback.track_at_next, None) + self.assertEqual(self.playback.tl_track_at_next, None) @populate_tracklist def test_end_of_track_track_at_end_of_playlist(self): self.playback.play() for _ in self.tracklist.tl_tracks[1:]: self.playback.on_end_of_track() - self.assertEqual(self.playback.track_at_next, None) + self.assertEqual(self.playback.tl_track_at_next, None) @populate_tracklist def test_end_of_track_track_at_end_of_playlist_with_repeat(self): @@ -400,13 +400,13 @@ class PlaybackControllerTest(object): self.playback.play() for _ in self.tracks[1:]: self.playback.on_end_of_track() - self.assertEqual(self.playback.track_at_next, self.tracks[0]) + self.assertEqual(self.playback.tl_track_at_next, self.tl_tracks[0]) @populate_tracklist def test_end_of_track_track_with_random(self): random.seed(1) self.playback.random = True - self.assertEqual(self.playback.track_at_next, self.tracks[2]) + self.assertEqual(self.playback.tl_track_at_next, self.tl_tracks[2]) @populate_tracklist def test_end_of_track_with_consume(self): @@ -428,9 +428,9 @@ class PlaybackControllerTest(object): def test_end_of_track_track_with_random_after_append_playlist(self): random.seed(1) self.playback.random = True - self.assertEqual(self.playback.track_at_next, self.tracks[2]) + self.assertEqual(self.playback.tl_track_at_next, self.tl_tracks[2]) self.tracklist.append(self.tracks[:1]) - self.assertEqual(self.playback.track_at_next, self.tracks[1]) + self.assertEqual(self.playback.tl_track_at_next, self.tl_tracks[1]) @populate_tracklist def test_previous_track_before_play(self): @@ -830,14 +830,14 @@ class PlaybackControllerTest(object): self.playback.play() for _ in self.tracks[1:]: self.playback.next() - self.assertEqual(self.playback.track_at_next, None) + self.assertEqual(self.playback.tl_track_at_next, None) @populate_tracklist def test_random_until_end_of_playlist_and_play_from_start(self): self.playback.repeat = True for _ in self.tracks: self.playback.next() - self.assertNotEqual(self.playback.track_at_next, None) + self.assertNotEqual(self.playback.tl_track_at_next, None) self.assertEqual(self.playback.state, PlaybackState.STOPPED) self.playback.play() self.assertEqual(self.playback.state, PlaybackState.PLAYING) @@ -849,7 +849,7 @@ class PlaybackControllerTest(object): self.playback.play() for _ in self.tracks: self.playback.next() - self.assertNotEqual(self.playback.track_at_next, None) + self.assertNotEqual(self.playback.tl_track_at_next, None) @populate_tracklist def test_played_track_during_random_not_played_again(self): From 4c19321500bebb67eba3dec9639482345b90c732 Mon Sep 17 00:00:00 2001 From: Stein Magnus Jodal Date: Tue, 20 Nov 2012 09:41:46 +0100 Subject: [PATCH 2/4] core: Remove playback.track_at_eot --- docs/changes.rst | 3 +++ mopidy/core/playback.py | 11 ----------- 2 files changed, 3 insertions(+), 11 deletions(-) diff --git a/docs/changes.rst b/docs/changes.rst index 4bdacd78..a3891424 100644 --- a/docs/changes.rst +++ b/docs/changes.rst @@ -152,6 +152,9 @@ backends: - Remove :attr:`mopidy.core.PlaybackController.track_at_next`. Use :attr:`mopidy.core.PlaybackController.tl_track_at_next` instead. +- Remove :attr:`mopidy.core.PlaybackController.track_at_eot`. Use + :attr:`mopidy.core.PlaybackController.tl_track_at_eot` instead. + - Added support for connecting to the Spotify service through an HTTP or SOCKS proxy, which is supported by pyspotify >= 1.9. diff --git a/mopidy/core/playback.py b/mopidy/core/playback.py index 613f21ba..cab2c392 100644 --- a/mopidy/core/playback.py +++ b/mopidy/core/playback.py @@ -115,17 +115,6 @@ class PlaybackController(object): Read-only. """ - def get_track_at_eot(self): - return self.tl_track_at_eot and self.tl_track_at_eot.track - - track_at_eot = property(get_track_at_eot) - """ - The track that will be played at the end of the current track. - - Read-only. A :class:`mopidy.models.Track` extracted from - :attr:`tl_track_at_eot` for convenience. - """ - def get_tl_track_at_eot(self): # pylint: disable = R0911 # Too many return statements From 2f2716767791cd21e51570b1d5a3d19115180419 Mon Sep 17 00:00:00 2001 From: Stein Magnus Jodal Date: Tue, 20 Nov 2012 09:44:09 +0100 Subject: [PATCH 3/4] core: Remove playback.track_at_previous --- docs/changes.rst | 3 +++ mopidy/core/playback.py | 11 ----------- tests/backends/base/playback.py | 16 +++++++++------- 3 files changed, 12 insertions(+), 18 deletions(-) diff --git a/docs/changes.rst b/docs/changes.rst index a3891424..77c418bf 100644 --- a/docs/changes.rst +++ b/docs/changes.rst @@ -149,6 +149,9 @@ backends: This makes it possible to support lookup of artist or album URIs which then can expand to a list of tracks. +- Remove :attr:`mopidy.core.PlaybackController.track_at_previous`. Use + :attr:`mopidy.core.PlaybackController.tl_track_at_previous` instead. + - Remove :attr:`mopidy.core.PlaybackController.track_at_next`. Use :attr:`mopidy.core.PlaybackController.tl_track_at_next` instead. diff --git a/mopidy/core/playback.py b/mopidy/core/playback.py index cab2c392..901c7e34 100644 --- a/mopidy/core/playback.py +++ b/mopidy/core/playback.py @@ -196,17 +196,6 @@ class PlaybackController(object): before the list repeats. """ - def get_track_at_previous(self): - return self.tl_track_at_previous and self.tl_track_at_previous.track - - track_at_previous = property(get_track_at_previous) - """ - The track that will be played if calling :meth:`previous()`. - - Read-only. A :class:`mopidy.models.Track` extracted from - :attr:`tl_track_at_previous` for convenience. - """ - def get_tl_track_at_previous(self): if self.repeat or self.consume or self.random: return self.current_tl_track diff --git a/tests/backends/base/playback.py b/tests/backends/base/playback.py index 619efbb2..fffe09da 100644 --- a/tests/backends/base/playback.py +++ b/tests/backends/base/playback.py @@ -434,18 +434,18 @@ class PlaybackControllerTest(object): @populate_tracklist def test_previous_track_before_play(self): - self.assertEqual(self.playback.track_at_previous, None) + self.assertEqual(self.playback.tl_track_at_previous, None) @populate_tracklist def test_previous_track_after_play(self): self.playback.play() - self.assertEqual(self.playback.track_at_previous, None) + self.assertEqual(self.playback.tl_track_at_previous, None) @populate_tracklist def test_previous_track_after_next(self): self.playback.play() self.playback.next() - self.assertEqual(self.playback.track_at_previous, self.tracks[0]) + self.assertEqual(self.playback.tl_track_at_previous, self.tl_tracks[0]) @populate_tracklist def test_previous_track_after_previous(self): @@ -453,10 +453,10 @@ class PlaybackControllerTest(object): self.playback.next() # At track 1 self.playback.next() # At track 2 self.playback.previous() # At track 1 - self.assertEqual(self.playback.track_at_previous, self.tracks[0]) + self.assertEqual(self.playback.tl_track_at_previous, self.tl_tracks[0]) def test_previous_track_empty_playlist(self): - self.assertEqual(self.playback.track_at_previous, None) + self.assertEqual(self.playback.tl_track_at_previous, None) @populate_tracklist def test_previous_track_with_consume(self): @@ -464,7 +464,8 @@ class PlaybackControllerTest(object): for _ in self.tracks: self.playback.next() self.assertEqual( - self.playback.track_at_previous, self.playback.current_track) + self.playback.tl_track_at_previous, + self.playback.current_tl_track) @populate_tracklist def test_previous_track_with_random(self): @@ -472,7 +473,8 @@ class PlaybackControllerTest(object): for _ in self.tracks: self.playback.next() self.assertEqual( - self.playback.track_at_previous, self.playback.current_track) + self.playback.tl_track_at_previous, + self.playback.current_tl_track) @populate_tracklist def test_initial_current_track(self): From d107b13fcbb16b2fb7fc0210f1607d6a1abad222 Mon Sep 17 00:00:00 2001 From: Stein Magnus Jodal Date: Tue, 20 Nov 2012 10:09:46 +0100 Subject: [PATCH 4/4] core: Remove playback.current_tlid --- docs/changes.rst | 3 +++ mopidy/core/playback.py | 11 ----------- mopidy/frontends/mpd/protocol/current_playlist.py | 3 ++- mopidy/frontends/mpd/protocol/playback.py | 9 +++++---- tests/frontends/mpd/protocol/playback_test.py | 2 +- 5 files changed, 11 insertions(+), 17 deletions(-) diff --git a/docs/changes.rst b/docs/changes.rst index 77c418bf..d664872b 100644 --- a/docs/changes.rst +++ b/docs/changes.rst @@ -158,6 +158,9 @@ backends: - Remove :attr:`mopidy.core.PlaybackController.track_at_eot`. Use :attr:`mopidy.core.PlaybackController.tl_track_at_eot` instead. +- Remove :attr:`mopidy.core.PlaybackController.current_tlid`. Use + :attr:`mopidy.core.PlaybackController.current_tl_track` instead. + - Added support for connecting to the Spotify service through an HTTP or SOCKS proxy, which is supported by pyspotify >= 1.9. diff --git a/mopidy/core/playback.py b/mopidy/core/playback.py index 901c7e34..94fd7d4e 100644 --- a/mopidy/core/playback.py +++ b/mopidy/core/playback.py @@ -79,17 +79,6 @@ class PlaybackController(object): uri_scheme = urlparse.urlparse(uri).scheme return self.backends.with_playback_by_uri_scheme.get(uri_scheme, None) - def get_current_tlid(self): - return self.current_tl_track and self.current_tl_track.tlid - - current_tlid = property(get_current_tlid) - """ - The TLID (tracklist ID) of the currently playing or selected - track. - - Read-only. Extracted from :attr:`current_tl_track` for convenience. - """ - def get_current_track(self): return self.current_tl_track and self.current_tl_track.track diff --git a/mopidy/frontends/mpd/protocol/current_playlist.py b/mopidy/frontends/mpd/protocol/current_playlist.py index da950078..69e04d4b 100644 --- a/mopidy/frontends/mpd/protocol/current_playlist.py +++ b/mopidy/frontends/mpd/protocol/current_playlist.py @@ -110,7 +110,8 @@ def deleteid(context, tlid): Deletes the song ``SONGID`` from the playlist """ tlid = int(tlid) - if context.core.playback.current_tlid.get() == tlid: + tl_track = context.core.playback.current_tl_track.get() + if tl_track and tl_track.tlid == tlid: context.core.playback.next() tl_tracks = context.core.tracklist.remove(tlid=tlid).get() if not tl_tracks: diff --git a/mopidy/frontends/mpd/protocol/playback.py b/mopidy/frontends/mpd/protocol/playback.py index d166f982..5a4569e1 100644 --- a/mopidy/frontends/mpd/protocol/playback.py +++ b/mopidy/frontends/mpd/protocol/playback.py @@ -329,9 +329,9 @@ def seek(context, songpos, seconds): - issues ``seek 1 120`` without quotes around the arguments. """ - if context.core.playback.tracklist_position != songpos: + if context.core.playback.tracklist_position.get() != songpos: playpos(context, songpos) - context.core.playback.seek(int(seconds) * 1000) + context.core.playback.seek(int(seconds) * 1000).get() @handle_request(r'^seekid "(?P\d+)" "(?P\d+)"$') @@ -343,9 +343,10 @@ def seekid(context, tlid, seconds): Seeks to the position ``TIME`` (in seconds) of song ``SONGID``. """ - if context.core.playback.current_tlid != tlid: + tl_track = context.core.playback.current_tl_track.get() + if not tl_track or tl_track.tlid != tlid: playid(context, tlid) - context.core.playback.seek(int(seconds) * 1000) + context.core.playback.seek(int(seconds) * 1000).get() @handle_request(r'^setvol (?P[-+]*\d+)$') diff --git a/tests/frontends/mpd/protocol/playback_test.py b/tests/frontends/mpd/protocol/playback_test.py index f81be241..9bf467f5 100644 --- a/tests/frontends/mpd/protocol/playback_test.py +++ b/tests/frontends/mpd/protocol/playback_test.py @@ -424,7 +424,7 @@ class PlaybackControlHandlerTest(protocol.BaseTestCase): [Track(uri='dummy:a', length=40000), seek_track]) self.sendRequest('seekid "1" "30"') - self.assertEqual(1, self.core.playback.current_tlid.get()) + self.assertEqual(1, self.core.playback.current_tl_track.get().tlid) self.assertEqual(seek_track, self.core.playback.current_track.get()) self.assertInResponse('OK')