def setUp(self): # noqa: N802 # TODO: use create_proxy helpers. self.audio = dummy_audio.DummyAudio.start().proxy() self.backend = TestBackend.start(audio=self.audio, config=self.config).proxy() self.core = core.Core(audio=self.audio, backends=[self.backend], config=self.config) self.playback = self.core.playback # We don't have a core actor running, so call about to finish directly. self.audio.set_about_to_finish_callback( self.playback._on_about_to_finish) with deprecation.ignore('core.tracklist.add:tracks_arg'): self.core.tracklist.add(self.tracks) self.events = [] self.patcher = mock.patch('mopidy.audio.listener.AudioListener.send') self.send_mock = self.patcher.start() def send(event, **kwargs): self.events.append((event, kwargs)) self.send_mock.side_effect = send
def search(context, *args): """ *musicpd.org, music database section:* ``search {TYPE} {WHAT} [...]`` Searches for any song that contains ``WHAT``. Parameters have the same meaning as for ``find``, except that search is not case sensitive. *GMPC:* - uses the undocumented field ``any``. - searches for multiple words like this:: search any "foo" any "bar" any "baz" *ncmpc:* - capitalizes the field argument. *ncmpcpp:* - also uses the search type "date". - uses "file" instead of "filename". """ try: query = _query_from_mpd_search_parameters(args, _SEARCH_MAPPING) except ValueError: return with deprecation.ignore('core.library.search:empty_query'): results = context.core.library.search(query).get() artists = [_artist_as_track(a) for a in _get_artists(results)] albums = [_album_as_track(a) for a in _get_albums(results)] tracks = _get_tracks(results) return translator.tracks_to_mpd_format(artists + albums + tracks)
def setup_method(self, method): self.audio = dummy_audio.create_proxy(config=self.config, mixer=None) self.backend = MyTestBackend.start( audio=self.audio, config=self.config ).proxy() self.core = core.Core( audio=self.audio, backends=[self.backend], config=self.config ) self.playback = self.core.playback # We don't have a core actor running, so call about to finish directly. self.audio.set_about_to_finish_callback( self.playback._on_about_to_finish ) with deprecation.ignore(): self.core.tracklist.add(self.tracks) self.events = [] self.patcher = mock.patch("mopidy.audio.listener.AudioListener.send") self.send_mock = self.patcher.start() def send(event, **kwargs): self.events.append((event, kwargs)) self.send_mock.side_effect = send
def run(self, result=None): with deprecation.ignore(ids=[ 'core.playlists.filter', 'core.playlists.filter:kwargs_criteria', 'core.playlists.get_playlists' ]): return super(DeprecatedM3UPlaylistsProviderTest, self).run(result)
def search(context, *args): """ *musicpd.org, music database section:* ``search {TYPE} {WHAT} [...]`` Searches for any song that contains ``WHAT``. Parameters have the same meaning as for ``find``, except that search is not case sensitive. *GMPC:* - uses the undocumented field ``any``. - searches for multiple words like this:: search any "foo" any "bar" any "baz" *ncmpc:* - capitalizes the field argument. *ncmpcpp:* - also uses the search type "date". - uses "file" instead of "filename". """ try: query = _query_from_mpd_search_parameters(args, _SEARCH_MAPPING) except ValueError: return with deprecation.ignore('core.library.search:empty_query'): results = context.core.library.search(query).get() artists = [_artist_as_track(a) for a in _get_artists(results)] albums = [_album_as_track(a) for a in _get_albums(results)] tracks = _get_tracks(results) return translator.tracks_to_mpd_format(artists + albums + tracks)
def test_add_by_uri_looks_up_uri_in_library(self): self.library.lookup.reset_mock() self.core.tracklist.clear() with deprecation.ignore('core.tracklist.add:uri_arg'): tl_tracks = self.core.tracklist.add(uris=['dummy1:a']) self.library.lookup.assert_called_once_with('dummy1:a') self.assertEqual(1, len(tl_tracks)) self.assertEqual(self.tracks[0], tl_tracks[0].track) self.assertEqual(tl_tracks, self.core.tracklist.tl_tracks[-1:])
def test_add_by_uri_looks_up_uri_in_library(self): self.library.lookup.reset_mock() self.core.tracklist.clear() with deprecation.ignore('core.tracklist.add:uri_arg'): tl_tracks = self.core.tracklist.add(uris=['dummy1:a']) self.library.lookup.assert_called_once_with('dummy1:a') self.assertEqual(1, len(tl_tracks)) self.assertEqual(self.tracks[0], tl_tracks[0].track) self.assertEqual(tl_tracks, self.core.tracklist.tl_tracks[-1:])
def test_seek_fails_for_track_without_duration(self): track = self.tracks[0].replace(length=None) self.core.tracklist.clear() with deprecation.ignore(): self.core.tracklist.add(tracks=[track]) self.core.playback.play() self.replay_events() assert not self.core.playback.seek(1000) assert 0 == self.core.playback.get_time_position()
def setUp(self): # noqa: N802 config = {"core": {"max_tracklist_length": 10000}} self.audio = dummy_audio.create_proxy() self.mixer = dummy_mixer.create_proxy() self.backend = dummy_backend.create_proxy(audio=self.audio) with deprecation.ignore(): self.core = core.Core.start(config, audio=self.audio, mixer=self.mixer, backends=[self.backend]).proxy() self.dispatcher = dispatcher.MpdDispatcher(core=self.core) self.context = self.dispatcher.context
def setUp(self): # noqa: N802 config = { 'mpd': { 'password': None, 'command_blacklist': ['disabled'], } } self.backend = dummy_backend.create_proxy() self.dispatcher = MpdDispatcher(config=config) with deprecation.ignore(): self.core = core.Core.start(backends=[self.backend]).proxy()
def setUp(self): # noqa: N802 config = { 'mpd': { 'password': None, 'command_blacklist': ['disabled'], } } self.backend = dummy_backend.create_proxy() self.dispatcher = MpdDispatcher(config=config) with deprecation.ignore(): self.core = core.Core.start(backends=[self.backend]).proxy()
def setUp(self): # noqa: N802 config = {"core": {"max_tracklist_length": 10000}} self.backend = dummy_backend.create_proxy() self.backend.library.dummy_library = [ Track(uri="dummy:a"), Track(uri="dummy:b"), ] with deprecation.ignore(): self.core = core.Core.start(config, backends=[self.backend]).proxy()
def test_pause_toggle(self): self.send_request('play "0"') self.assertEqual(PLAYING, self.core.playback.state.get()) self.assertInResponse('OK') with deprecation.ignore('mpd.protocol.playback.pause:state_arg'): self.send_request('pause') self.assertEqual(PAUSED, self.core.playback.state.get()) self.assertInResponse('OK') self.send_request('pause') self.assertEqual(PLAYING, self.core.playback.state.get()) self.assertInResponse('OK')
def test_play(self): self.core.tracklist.clear() with deprecation.ignore(): self.core.tracklist.add(tracks=self.tracks_play) self.backend.playback.reset_call_limit().get() self.core.tracklist.set_repeat(True) tl_tracks = self.core.tracklist.get_tl_tracks() self.core.playback.play(tl_tracks[0]) self.replay_events() assert not self.backend.playback.is_call_limit_reached().get()
def test_pause_toggle(self): self.send_request('play "0"') self.assertEqual(PLAYING, self.core.playback.state.get()) self.assertInResponse('OK') with deprecation.ignore('mpd.protocol.playback.pause:state_arg'): self.send_request('pause') self.assertEqual(PAUSED, self.core.playback.state.get()) self.assertInResponse('OK') self.send_request('pause') self.assertEqual(PLAYING, self.core.playback.state.get()) self.assertInResponse('OK')
def test_on_about_to_finish_skips_over_change_track_unplayable(self): # Makes translate_uri return None. track = Track(uri="dummy:unplayable", length=1234) with deprecation.ignore(): self.core.tracklist.add(tracks=[track], at_position=1) tl_tracks = self.core.tracklist.get_tl_tracks() self.core.playback.play(tl_tracks[0]) self.replay_events() self.trigger_about_to_finish() assert self.core.playback.get_current_tl_track() == tl_tracks[2]
def test_on_about_to_finish_skips_over_change_track_error(self): # Trigger an exception in translate_uri. track = Track(uri="dummy:error", length=1234) with deprecation.ignore(): self.core.tracklist.add(tracks=[track], at_position=1) tl_tracks = self.core.tracklist.get_tl_tracks() self.core.playback.play(tl_tracks[0]) self.replay_events() self.trigger_about_to_finish() assert self.core.playback.get_current_tl_track() == tl_tracks[2]
def setUp(self): # noqa: N802 config = { 'core': { 'max_tracklist_length': 10000, } } self.backend = dummy_backend.create_proxy() self.backend.library.dummy_library = [ Track(uri='dummy:a'), Track(uri='dummy:b')] with deprecation.ignore(): self.core = core.Core.start( config, backends=[self.backend]).proxy()
def test_on_about_to_finish(self): self.core.tracklist.clear() with deprecation.ignore(): self.core.tracklist.add(tracks=self.tracks_other) self.backend.playback.reset_call_limit().get() self.core.tracklist.set_repeat(True) tl_tracks = self.core.tracklist.get_tl_tracks() self.core.playback.play(tl_tracks[1]) self.replay_events() self.trigger_about_to_finish() assert not self.backend.playback.is_call_limit_reached().get()
def setUp(self): # noqa: N802 config = { 'core': { 'max_tracklist_length': 10000, } } self.backend = dummy_backend.create_proxy() self.backend.library.dummy_library = [ Track(uri='dummy:a'), Track(uri='dummy:b') ] with deprecation.ignore(): self.core = core.Core.start(config, backends=[self.backend]).proxy()
def setUp(self): # noqa: N802 config = { 'core': { 'max_tracklist_length': 10000, } } self.backend = mock.Mock() self.backend.uri_schemes.get.return_value = ['dummy'] self.core = core.Core(config, backends=[self.backend]) self.tracks = [Track(uri='dummy:a', length=1234), Track(uri='dummy:b', length=1234)] with deprecation.ignore('core.tracklist.add:tracks_arg'): self.tl_tracks = self.core.tracklist.add(tracks=self.tracks)
def get_eot_tlid(self): """ The TLID of the track that will be played after the current track. Not necessarily the same TLID as returned by :meth:`get_next_tlid`. :rtype: :class:`int` or :class:`None` .. versionadded:: 1.1 """ current_tl_track = self.core.playback.get_current_tl_track() with deprecation.ignore("core.tracklist.eot_track"): eot_tl_track = self.eot_track(current_tl_track) return getattr(eot_tl_track, "tlid", None)
def setUp(self): # noqa: N802 config = { 'core': { 'max_tracklist_length': 10000, } } self.mixer = dummy_mixer.create_proxy() self.backend = dummy_backend.create_proxy() with deprecation.ignore(): self.core = core.Core.start(config, mixer=self.mixer, backends=[self.backend]).proxy() self.dispatcher = dispatcher.MpdDispatcher(core=self.core) self.context = self.dispatcher.context
def test(self): track = Track(uri="dummy:d", length=1234, name="baz") with deprecation.ignore(): self.core.tracklist.add(tracks=[track], at_position=1) self.core.playback.play() self.replay_events() self.trigger_about_to_finish(replay_until="stream_changed") self.audio.trigger_fake_tags_changed({"title": ["foo"]}).get() self.replay_events() self.audio.trigger_fake_tags_changed({"title": ["baz"]}).get() self.replay_events() assert self.playback.get_current_track().uri == "dummy:d" assert self.playback.get_stream_title() is None
def setUp(self): # noqa: N802 config = { 'core': { 'max_tracklist_length': 10000, } } self.backend = mock.Mock() self.backend.uri_schemes.get.return_value = ['dummy'] self.core = core.Core(config, backends=[self.backend]) self.tracks = [ Track(uri='dummy:a', length=1234), Track(uri='dummy:b', length=1234) ] with deprecation.ignore('core.tracklist.add:tracks_arg'): self.tl_tracks = self.core.tracklist.add(tracks=self.tracks)
def get_previous_tlid(self): """ Returns the TLID of the track that will be played if calling :meth:`mopidy.core.PlaybackController.previous()`. For normal playback this is the previous track in the tracklist. If random and/or consume is enabled it should return the current track instead. :rtype: :class:`int` or :class:`None` .. versionadded:: 1.1 """ current_tl_track = self.core.playback.get_current_tl_track() with deprecation.ignore("core.tracklist.previous_track"): previous_tl_track = self.previous_track(current_tl_track) return getattr(previous_tl_track, "tlid", None)
def setUp(self): # noqa: N802 self.backend = dummy_backend.create_proxy() self.calc = Calculator() with deprecation.ignore(): self.core = core.Core.start(backends=[self.backend]).proxy() self.jrw = jsonrpc.JsonRpcWrapper( objects={ "hello": lambda: "Hello, world!", "calc": self.calc, "core": self.core, "core.playback": self.core.playback, "core.tracklist": self.core.tracklist, "get_uri_schemes": self.core.get_uri_schemes, }, encoders=[models.ModelJSONEncoder], decoders=[models.model_json_decoder], )
def setUp(self): # noqa: N802 self.backend = dummy_backend.create_proxy() self.calc = Calculator() with deprecation.ignore(): self.core = core.Core.start(backends=[self.backend]).proxy() self.jrw = jsonrpc.JsonRpcWrapper( objects={ "hello": lambda: "Hello, world!", "calc": self.calc, "core": self.core, "core.playback": self.core.playback, "core.tracklist": self.core.tracklist, "get_uri_schemes": self.core.get_uri_schemes, }, encoders=[models.ModelJSONEncoder], decoders=[models.model_json_decoder], )
def find(context, *args): """ *musicpd.org, music database section:* ``find {TYPE} {WHAT}`` Finds songs in the db that are exactly ``WHAT``. ``TYPE`` can be any tag supported by MPD, or one of the two special parameters - ``file`` to search by full path (relative to database root), and ``any`` to match against all available tags. ``WHAT`` is what to find. *GMPC:* - also uses ``find album "[ALBUM]" artist "[ARTIST]"`` to list album tracks. *ncmpc:* - capitalizes the type argument. *ncmpcpp:* - also uses the search type "date". - uses "file" instead of "filename". """ try: query = _query_from_mpd_search_parameters(args, _SEARCH_MAPPING) except ValueError: return with deprecation.ignore('core.library.search:empty_query'): results = context.core.library.search(query=query, exact=True).get() result_tracks = [] if ('artist' not in query and 'albumartist' not in query and 'composer' not in query and 'performer' not in query): result_tracks += [_artist_as_track(a) for a in _get_artists(results)] if 'album' not in query: result_tracks += [_album_as_track(a) for a in _get_albums(results)] result_tracks += _get_tracks(results) return translator.tracks_to_mpd_format(result_tracks)
def setUp(self): # noqa: N802 if self.enable_mixer: self.mixer = dummy_mixer.create_proxy() else: self.mixer = None self.backend = dummy_backend.create_proxy() with deprecation.ignore(): self.core = core.Core.start( self.get_config(), mixer=self.mixer, backends=[self.backend]).proxy() self.uri_map = uri_mapper.MpdUriMapper(self.core) self.connection = MockConnection() self.session = session.MpdSession( self.connection, config=self.get_config(), core=self.core, uri_map=self.uri_map) self.dispatcher = self.session.dispatcher self.context = self.dispatcher.context
def get_next_tlid(self): """ The tlid of the track that will be played if calling :meth:`mopidy.core.PlaybackController.next()`. For normal playback this is the next track in the tracklist. If repeat is enabled the next track can loop around the tracklist. When random is enabled this should be a random track, all tracks should be played once before the tracklist repeats. :rtype: :class:`int` or :class:`None` .. versionadded:: 1.1 """ current_tl_track = self.core.playback.get_current_tl_track() with deprecation.ignore("core.tracklist.next_track"): next_tl_track = self.next_track(current_tl_track) return getattr(next_tl_track, "tlid", None)
def setUp(self): # noqa: N802 if self.enable_mixer: self.mixer = dummy_mixer.create_proxy() else: self.mixer = None self.backend = dummy_backend.create_proxy() with deprecation.ignore(): self.core = core.Core.start(self.get_config(), mixer=self.mixer, backends=[self.backend]).proxy() self.uri_map = uri_mapper.MpdUriMapper(self.core) self.connection = MockConnection() self.session = session.MpdSession(self.connection, config=self.get_config(), core=self.core, uri_map=self.uri_map) self.dispatcher = self.session.dispatcher self.context = self.dispatcher.context
def findadd(context, *args): """ *musicpd.org, music database section:* ``findadd {TYPE} {WHAT}`` Finds songs in the db that are exactly ``WHAT`` and adds them to current playlist. Parameters have the same meaning as for ``find``. """ try: query = _query_from_mpd_search_parameters(args, _SEARCH_MAPPING) except ValueError: return results = context.core.library.search(query=query, exact=True).get() with deprecation.ignore('core.tracklist.add:tracks_arg'): # TODO: for now just use tracks as other wise we have to lookup the # tracks we just got from the search. context.core.tracklist.add(tracks=_get_tracks(results)).get()
def findadd(context, *args): """ *musicpd.org, music database section:* ``findadd {TYPE} {WHAT}`` Finds songs in the db that are exactly ``WHAT`` and adds them to current playlist. Parameters have the same meaning as for ``find``. """ try: query = _query_from_mpd_search_parameters(args, _SEARCH_MAPPING) except ValueError: return results = context.core.library.search(query=query, exact=True).get() with deprecation.ignore('core.tracklist.add:tracks_arg'): # TODO: for now just use tracks as other wise we have to lookup the # tracks we just got from the search. context.core.tracklist.add(tracks=_get_tracks(results)).get()
def swap(context, songpos1, songpos2): """ *musicpd.org, current playlist section:* ``swap {SONG1} {SONG2}`` Swaps the positions of ``SONG1`` and ``SONG2``. """ tracks = context.core.tracklist.get_tracks().get() song1 = tracks[songpos1] song2 = tracks[songpos2] del tracks[songpos1] tracks.insert(songpos1, song2) del tracks[songpos2] tracks.insert(songpos2, song1) # TODO: do we need a tracklist.replace() context.core.tracklist.clear() with deprecation.ignore('core.tracklist.add:tracks_arg'): context.core.tracklist.add(tracks=tracks).get()
def find(context, *args): """ *musicpd.org, music database section:* ``find {TYPE} {WHAT}`` Finds songs in the db that are exactly ``WHAT``. ``TYPE`` can be any tag supported by MPD, or one of the two special parameters - ``file`` to search by full path (relative to database root), and ``any`` to match against all available tags. ``WHAT`` is what to find. *GMPC:* - also uses ``find album "[ALBUM]" artist "[ARTIST]"`` to list album tracks. *ncmpc:* - capitalizes the type argument. *ncmpcpp:* - also uses the search type "date". - uses "file" instead of "filename". """ try: query = _query_from_mpd_search_parameters(args, _SEARCH_MAPPING) except ValueError: return with deprecation.ignore('core.library.search:empty_query'): results = context.core.library.search(query=query, exact=True).get() result_tracks = [] if ('artist' not in query and 'albumartist' not in query and 'composer' not in query and 'performer' not in query): result_tracks += [_artist_as_track(a) for a in _get_artists(results)] if 'album' not in query: result_tracks += [_album_as_track(a) for a in _get_albums(results)] result_tracks += _get_tracks(results) return translator.tracks_to_mpd_format(result_tracks)
def searchadd(context, *args): """ *musicpd.org, music database section:* ``searchadd {TYPE} {WHAT} [...]`` Searches for any song that contains ``WHAT`` in tag ``TYPE`` and adds them to current playlist. Parameters have the same meaning as for ``find``, except that search is not case sensitive. """ try: query = _query_from_mpd_search_parameters(args, _SEARCH_MAPPING) except ValueError: return results = context.core.library.search(query).get() with deprecation.ignore('core.tracklist.add:tracks_arg'): # TODO: for now just use tracks as other wise we have to lookup the # tracks we just got from the search. context.core.tracklist.add(_get_tracks(results)).get()
def setUp(self): # noqa: N802 self.backend = dummy_backend.create_proxy() self.calc = Calculator() with deprecation.ignore(): self.core = core.Core.start(backends=[self.backend]).proxy() self.jrw = jsonrpc.JsonRpcWrapper(objects={ 'hello': lambda: 'Hello, world!', 'calc': self.calc, 'core': self.core, 'core.playback': self.core.playback, 'core.tracklist': self.core.tracklist, 'get_uri_schemes': self.core.get_uri_schemes, }, encoders=[models.ModelJSONEncoder], decoders=[models.model_json_decoder])
def searchadd(context, *args): """ *musicpd.org, music database section:* ``searchadd {TYPE} {WHAT} [...]`` Searches for any song that contains ``WHAT`` in tag ``TYPE`` and adds them to current playlist. Parameters have the same meaning as for ``find``, except that search is not case sensitive. """ try: query = _query_from_mpd_search_parameters(args, _SEARCH_MAPPING) except ValueError: return results = context.core.library.search(query).get() with deprecation.ignore('core.tracklist.add:tracks_arg'): # TODO: for now just use tracks as other wise we have to lookup the # tracks we just got from the search. context.core.tracklist.add(_get_tracks(results)).get()
def test(self): config = {"core": {"max_tracklist_length": 10000}} b = mock.Mock() b.uri_schemes.get.return_value = ["dummy"] b.playback = mock.Mock(spec=backend.PlaybackProvider) b.playback.change_track.return_value.get.return_value = True b.playback.play.return_value.get.return_value = True track1 = Track(uri="dummy:a", length=40000) track2 = Track(uri="dummy:b", length=40000) c = core.Core(config, mixer=None, backends=[b]) with deprecation.ignore(): c.tracklist.add(tracks=[track1, track2]) c.playback.play() b.playback.change_track.assert_called_once_with(track1) b.playback.change_track.reset_mock() c.playback.pause() c.playback.next() b.playback.change_track.assert_called_once_with(track2)
def setUp(self): # noqa: N802 # TODO: use create_proxy helpers. self.audio = dummy_audio.DummyAudio.start().proxy() self.backend = TestBackend.start( audio=self.audio, config=self.config).proxy() self.core = core.Core( audio=self.audio, backends=[self.backend], config=self.config) self.playback = self.core.playback # We don't have a core actor running, so call about to finish directly. self.audio.set_about_to_finish_callback( self.playback._on_about_to_finish) with deprecation.ignore('core.tracklist.add:tracks_arg'): self.core.tracklist.add(self.tracks) self.events = [] self.patcher = mock.patch('mopidy.audio.listener.AudioListener.send') self.send_mock = self.patcher.start() def send(event, **kwargs): self.events.append((event, kwargs)) self.send_mock.side_effect = send
def setup_method(self, method): config = {"core": {"max_tracklist_length": 10000}} self.backend1 = mock.Mock() self.backend1.uri_schemes.get.return_value = ["dummy1"] self.playback1 = mock.Mock(spec=backend.PlaybackProvider) self.backend1.playback = self.playback1 self.backend2 = mock.Mock() self.backend2.uri_schemes.get.return_value = ["dummy2"] self.playback2 = mock.Mock(spec=backend.PlaybackProvider) self.backend2.playback = self.playback2 self.tracks = [ Track(uri="dummy1:a", length=40000), Track(uri="dummy2:a", length=40000), ] self.core = core.Core(config, mixer=None, backends=[self.backend1, self.backend2]) with deprecation.ignore(): self.tl_tracks = self.core.tracklist.add(tracks=self.tracks)
def run(self, result=None): with deprecation.ignore('core.tracklist.add:tracks_arg'): return super(LocalPlaybackProviderTest, self).run(result)
def run(self, result=None): with deprecation.ignore('core.tracklist.add:tracks_arg'): return super(LocalTracklistProviderTest, self).run(result)
def run(self, result=None): with deprecation.ignore('core.library.find_exact'): return super(LegacyFindExactToSearchLibraryTest, self).run(result)
def run(self, result=None): with deprecation.ignore('core.library.lookup:uri_arg'): return super(DeprecatedLookupCoreLibraryTest, self).run(result)
def run(self, result=None): with deprecation.ignore('core.library.find_exact'): return super(DeprecatedFindExactCoreLibraryTest, self).run(result)
def run(self, result=None): with deprecation.ignore(ids=['core.playlists.filter', 'core.playlists.get_playlists']): return super(DeprecatedFilterPlaylistsTest, self).run(result)
def run(self, result=None): with deprecation.ignore('core.playlists.get_playlists'): return super(DeprecatedGetPlaylistsTest, self).run(result)
def test_playlist_returns_same_as_playlistinfo(self): with deprecation.ignore('mpd.protocol.current_playlist.playlist'): playlist_response = self.send_request('playlist') playlistinfo_response = self.send_request('playlistinfo') self.assertEqual(playlist_response, playlistinfo_response)
def wrapper(self): with deprecation.ignore('core.tracklist.add:tracks_arg'): self.tl_tracks = self.core.tracklist.add(self.tracks) return func(self)
def run(self, result=None): with deprecation.ignore(ids=['core.playlists.filter', 'core.playlists.filter:kwargs_criteria', 'core.playlists.get_playlists']): return super(DeprecatedM3UPlaylistsProviderTest, self).run(result)