def test_browse_root(backend, servers): with mock.patch.object(backend, 'client') as m: m.servers.return_value = Future.fromvalue(servers) assert backend.library.browse(backend.library.root_directory.uri) == [ Ref.directory(name='Media Server #1', uri='dleyna://media1'), Ref.directory(name='Media Server #2', uri='dleyna://media2'), ]
def country_to_ref(country_code): uri = unparse_uri('country', country_code.lower()) try: country = pycountry.countries.get(alpha2=country_code.upper()) return Ref.directory(uri=uri, name=country.name) except KeyError: return Ref.directory(uri=uri, name=country_code.upper())
def __init__(self, *args, **kwargs): super(GMusicLibraryProvider, self).__init__(*args, **kwargs) # tracks, albums, and artists here refer to what is explicitly # in our library. self.tracks = {} self.albums = {} self.artists = {} # aa_* caches are *only* used for temporary objects. Library # objects will never make it here. self.aa_artists = LRUCache(1024) self.aa_tracks = LRUCache(1024) self.aa_albums = LRUCache(1024) self._radio_stations_in_browse = ( self.backend.config['gmusic']['radio_stations_in_browse']) self._radio_stations_count = ( self.backend.config['gmusic']['radio_stations_count']) self._radio_tracks_count = ( self.backend.config['gmusic']['radio_tracks_count']) self._top_tracks_count = ( self.backend.config['gmusic']['top_tracks_count']) # Setup the root of library browsing. self._root = [ Ref.directory(uri='gmusic:album', name='Albums'), Ref.directory(uri='gmusic:artist', name='Artists'), Ref.directory(uri='gmusic:track', name='Tracks') ] if self._radio_stations_in_browse: self._root.append(Ref.directory(uri='gmusic:radio', name='Radios'))
def spotify_browse_process_results(results): logger.debug('Processing spotify browse result') if 'categories' in results: result_list = results['categories'] browse_uri = 'spotifyweb:browse:categories:' arr = [Ref.directory(uri=browse_uri + cat['id'], name=cat['name']) for cat in result_list['items']] elif 'playlists' in results: result_list = results['playlists'] arr = [Ref.playlist(uri=playlist['uri'], name=playlist['name']) for playlist in result_list['items']] elif 'albums' in results: result_list = results['albums'] arr = [Ref.album(uri=album['uri'], name=album['name']) for album in result_list['items']] else: result_list = None arr = [] cont = result_list is not None and result_list['next'] is not None logger.debug('Spotify browse result cont: %s' % cont) return arr, cont
def setUp(self): dummy1_root = Ref.directory(uri='dummy1:directory', name='dummy1') self.backend1 = mock.Mock() self.backend1.uri_schemes.get.return_value = ['dummy1'] self.backend1.actor_ref.actor_class.__name__ = 'dummy1' self.library1 = mock.Mock(spec=backend.LibraryProvider) self.library1.root_directory.get.return_value = dummy1_root self.backend1.library = self.library1 dummy2_root = Ref.directory(uri='dummy2:directory', name='dummy2') self.backend2 = mock.Mock() self.backend2.uri_schemes.get.return_value = ['dummy2'] self.backend2.actor_ref.actor_class.__name__ = 'dummy2' self.library2 = mock.Mock(spec=backend.LibraryProvider) self.library2.root_directory.get.return_value = dummy2_root self.backend2.library = self.library2 # A backend without the optional library provider self.backend3 = mock.Mock() self.backend3.uri_schemes.get.return_value = ['dummy3'] self.backend3.actor_ref.actor_class.__name__ = 'dummy3' self.backend3.has_library().get.return_value = False self.backend3.has_library_browse().get.return_value = False self.core = core.Core(audio=None, backends=[ self.backend1, self.backend2, self.backend3])
def __init__(self, *args, **kwargs): super(GMusicLibraryProvider, self).__init__(*args, **kwargs) self.tracks = {} self.albums = {} self.artists = {} self.aa_artists = {} self.aa_tracks = LruCache() self.aa_albums = LruCache() self.all_access = False self._radio_stations_in_browse = ( self.backend.config['gmusic']['radio_stations_in_browse']) self._radio_stations_count = ( self.backend.config['gmusic']['radio_stations_count']) self._radio_tracks_count = ( self.backend.config['gmusic']['radio_tracks_count']) self._root = [] self._root.append(Ref.directory(uri='gmusic:album', name='Albums')) self._root.append(Ref.directory(uri='gmusic:artist', name='Artists')) # browsing all tracks results in connection timeouts # self._root.append(Ref.directory(uri='gmusic:track', name='Tracks')) if self._radio_stations_in_browse: self._root.append(Ref.directory(uri='gmusic:radio', name='Radios')) # show root only if there is something to browse if len(self._root) > 0: GMusicLibraryProvider.root_directory = Ref.directory( uri='gmusic:directory', name='Google Music')
def ref(obj, uri=uri): identifier = obj['identifier'] mediatype = obj['mediatype'] if mediatype == 'collection': return Ref.directory(name=name(obj), uri=uri(identifier)) else: return Ref.album(name=name(obj), uri=uri(identifier))
def setUp(self): # noqa: N802 dummy1_root = Ref.directory(uri='dummy1:directory', name='dummy1') self.backend1 = mock.Mock() self.backend1.uri_schemes.get.return_value = ['dummy1'] self.backend1.actor_ref.actor_class.__name__ = 'DummyBackend1' self.library1 = mock.Mock(spec=backend.LibraryProvider) self.library1.get_images.return_value.get.return_value = {} self.library1.root_directory.get.return_value = dummy1_root self.backend1.library = self.library1 self.backend1.has_playlists.return_value.get.return_value = False dummy2_root = Ref.directory(uri='dummy2:directory', name='dummy2') self.backend2 = mock.Mock() self.backend2.uri_schemes.get.return_value = ['dummy2', 'du2'] self.backend2.actor_ref.actor_class.__name__ = 'DummyBackend2' self.library2 = mock.Mock(spec=backend.LibraryProvider) self.library2.get_images.return_value.get.return_value = {} self.library2.root_directory.get.return_value = dummy2_root self.backend2.library = self.library2 self.backend2.has_playlists.return_value.get.return_value = False # A backend without the optional library provider self.backend3 = mock.Mock() self.backend3.uri_schemes.get.return_value = ['dummy3'] self.backend3.actor_ref.actor_class.__name__ = 'DummyBackend3' self.backend3.has_library.return_value.get.return_value = False self.backend3.has_library_browse.return_value.get.return_value = False self.core = core.Core(mixer=None, backends=[ self.backend1, self.backend2, self.backend3])
def test_browse_root(config, library, genres): responses.add(responses.GET, re.compile(r'.*/genres\b.*'), json=genres) assert library.browse('podcast+itunes:') == [ Ref.directory(name='Top Podcasts', uri='podcast+itunes:charts:26'), Ref.directory(name='Bar', uri='podcast+itunes:genre:1001'), Ref.directory(name='Foo', uri='podcast+itunes:charts:1000') ]
def setUp(self): # noqa: N802 dummy1_root = Ref.directory(uri='dummy1:directory', name='dummy1') self.backend1 = mock.Mock() self.backend1.uri_schemes.get.return_value = ['dummy1'] self.library1 = mock.Mock(spec=backend.LibraryProvider) self.library1.get_images().get.return_value = {} self.library1.get_images.reset_mock() self.library1.root_directory.get.return_value = dummy1_root self.backend1.library = self.library1 dummy2_root = Ref.directory(uri='dummy2:directory', name='dummy2') self.backend2 = mock.Mock() self.backend2.uri_schemes.get.return_value = ['dummy2', 'du2'] self.library2 = mock.Mock(spec=backend.LibraryProvider) self.library2.get_images().get.return_value = {} self.library2.get_images.reset_mock() self.library2.root_directory.get.return_value = dummy2_root self.backend2.library = self.library2 # A backend without the optional library provider self.backend3 = mock.Mock() self.backend3.uri_schemes.get.return_value = ['dummy3'] self.backend3.has_library().get.return_value = False self.backend3.has_library_browse().get.return_value = False self.core = core.Core(mixer=None, backends=[ self.backend1, self.backend2, self.backend3])
def _browse_directory(self, uri, order=('type', 'name')): query = dict(uritools.urisplit(uri).getquerylist()) type = query.pop('type', None) role = query.pop('role', None) # TODO: handle these in schema (generically)? if type == 'date': format = query.get('format', '%Y-%m-%d') return map(_dateref, schema.dates(self._connect(), format=format)) if type == 'genre': return map(_genreref, schema.list_distinct(self._connect(), 'genre')) # noqa # Fix #38: keep sort order of album tracks; this also applies # to composers and performers if type == Ref.TRACK and 'album' in query: order = ('disc_no', 'track_no', 'name') roles = role or ('artist', 'albumartist') # FIXME: re-think 'roles'... refs = [] for ref in schema.browse(self._connect(), type, order, role=roles, **query): # noqa if ref.type == Ref.TRACK or (not query and not role): refs.append(ref) elif ref.type == Ref.ALBUM: refs.append(Ref.directory(uri=uritools.uricompose( 'local', None, 'directory', dict(query, type=Ref.TRACK, album=ref.uri) # noqa ), name=ref.name)) elif ref.type == Ref.ARTIST: refs.append(Ref.directory(uri=uritools.uricompose( 'local', None, 'directory', dict(query, **{role: ref.uri}) ), name=ref.name)) else: logger.warn('Unexpected SQLite browse result: %r', ref) return refs
def test_as_list_with_folders_and_ignored_unloaded_playlist(provider): result = provider.as_list() assert len(result) == 2 assert result[0] == Ref.playlist(uri="spotify:user:alice:playlist:foo", name="Foo") assert result[1] == Ref.playlist(uri="spotify:playlist:bob:baz", name="Bar/Baz (by bob)")
def test_lsinfo_duplicate(self): self.backend.library.dummy_browse_result = { "dummy:/": [Ref.directory(uri="dummy:/a1", name="a"), Ref.directory(uri="dummy:/a2", name="a")] } self.sendRequest('lsinfo "/dummy"') self.assertInResponse("directory: dummy/a") self.assertInResponse("directory: dummy/a [2]")
def test_lsinfo_for_dir_with_and_without_leading_slash_is_the_same(self): self.backend.library.dummy_browse_result = { "dummy:/": [Ref.track(uri="dummy:/a", name="a"), Ref.directory(uri="dummy:/foo", name="foo")] } response1 = self.sendRequest('lsinfo "dummy"') response2 = self.sendRequest('lsinfo "/dummy"') self.assertEqual(response1, response2)
def test_lsinfo_for_root_includes_dirs_for_each_lib_with_content(self): self.backend.library.dummy_browse_result = { "dummy:/": [Ref.track(uri="dummy:/a", name="a"), Ref.directory(uri="dummy:/foo", name="foo")] } self.sendRequest('lsinfo "/"') self.assertInResponse("directory: dummy") self.assertInResponse("OK")
def test_browse_subgenre(config, library, genres, charts, lookup): responses.add(responses.GET, re.compile(r'.*/genres\b.*'), json=genres) responses.add(responses.GET, re.compile(r'.*/charts\b.*'), json=charts) responses.add(responses.GET, re.compile(r'.*/lookup\b.*'), json=lookup) assert library.browse('podcast+itunes:genre:1001') == [ Ref.directory(name='Top Bar', uri='podcast+itunes:charts:1001'), Ref.directory(name='Baz', uri='podcast+itunes:charts:1002') ]
def test_browse_charts(config, library, genres, charts, lookup): responses.add(responses.GET, re.compile(r'.*/genres\b.*'), json=genres) responses.add(responses.GET, re.compile(r'.*/charts\b.*'), json=charts) responses.add(responses.GET, re.compile(r'.*/lookup\b.*'), json=lookup) assert library.browse('podcast+itunes:charts:1000') == [ Ref.album(name='foo', uri='podcast+http://example.com/1234'), Ref.album(name='bar', uri='podcast+http://example.com/5678') ]
def test_as_list(self): result = self.provider.as_list() self.assertEqual(len(result), 2) self.assertEqual( result[0], Ref.playlist(uri='gmusic:playlist:boo', name='boo')) self.assertEqual( result[1], Ref.playlist(uri='gmusic:playlist:foo', name='foo'))
def _ref(metadata): identifier = metadata['identifier'] uri = uritools.uricompose(SCHEME, path=identifier) name = metadata.get('title', identifier) if metadata.get('mediatype', 'collection') == 'collection': return Ref.directory(uri=uri, name=name) else: return Ref.album(uri=uri, name=name)
def test_lsinfo_for_dir_with_and_without_trailing_slash_is_the_same(self): self.backend.library.dummy_browse_result = { 'dummy:/': [Ref.track(uri='dummy:/a', name='a'), Ref.directory(uri='dummy:/foo', name='foo')]} response1 = self.sendRequest('lsinfo "dummy"') response2 = self.sendRequest('lsinfo "dummy/"') self.assertEqual(response1, response2)
def test_lsinfo_for_root_includes_dirs_for_each_lib_with_content(self): self.backend.library.dummy_browse_result = { 'dummy:/': [Ref.track(uri='dummy:/a', name='a'), Ref.directory(uri='dummy:/foo', name='foo')]} self.sendRequest('lsinfo "/"') self.assertInResponse('directory: dummy') self.assertInResponse('OK')
def test_lsinfo_for_dir_does_not_include_self(self): self.backend.library.dummy_browse_result = { 'dummy:/': [Ref.directory(uri='dummy:/foo', name='foo')], 'dummy:/foo': [Ref.track(uri='dummy:/a', name='a')]} self.sendRequest('lsinfo "/dummy"') self.assertNotInResponse('directory: dummy') self.assertInResponse('OK')
def test_lsinfo_duplicate(self): self.backend.library.dummy_browse_result = { 'dummy:/': [Ref.directory(uri='dummy:/a1', name='a'), Ref.directory(uri='dummy:/a2', name='a')]} self.sendRequest('lsinfo "/dummy"') self.assertInResponse('directory: dummy/a') self.assertInResponse('directory: dummy/a [2]')
def to_mopidy_track_ref(spotify_track): uri = str(spotify.Link.from_track(spotify_track, 0)) if not spotify_track.is_loaded(): return Ref.track(uri=uri, name='[loading] %s' % uri) name = spotify_track.name() if spotify_track.availability() != TRACK_AVAILABLE: name = '[unplayable] %s' % name return Ref.track(uri=uri, name=name)
def test_lsinfo_for_dir_does_not_include_self(self): self.backend.library.dummy_browse_result = { "dummy:/": [Ref.directory(uri="dummy:/foo", name="foo")], "dummy:/foo": [Ref.track(uri="dummy:/a", name="a")], } self.sendRequest('lsinfo "/dummy"') self.assertNotInResponse("directory: dummy") self.assertInResponse("OK")
def test_browse_items(backend, container, items): # FIXME: how to patch multiple object methods... with mock.patch.object(backend, 'client') as m: m.properties.return_value = Future.fromvalue(container) m.browse.return_value = Future.fromvalue(items) assert backend.library.browse(container['URI']) == [ Ref.track(name='Track #1', uri='dleyna://media/1'), Ref.track(name='Track #2', uri='dleyna://media/2') ]
def test_lsinfo_for_root_returns_browse_result_before_playlists(self): last_modified = 1390942873222 self.backend.library.dummy_browse_result = { "dummy:/": [Ref.track(uri="dummy:/a", name="a"), Ref.directory(uri="dummy:/foo", name="foo")] } self.backend.playlists.playlists = [Playlist(name="a", uri="dummy:/a", last_modified=last_modified)] response = self.sendRequest('lsinfo "/"') self.assertLess(response.index("directory: dummy"), response.index("playlist: a"))
def browse(self, uri): logger.debug("Request to browse %s in SpotifyWebLibraryProvider", uri) if uri == self.root_directory.uri: return self._root elif uri == 'spotifyweb:artists': return self._cache.sortedArtists # return Ref directory with all artists elif uri.startswith('spotifyweb:artist:'): # get artist uri return self._cache.artists2albums.get(uri) # return Ref directory with all albums for artist elif uri.startswith('spotifyweb:album:'): # get album uri return self._cache.albums2tracks.get(uri) # return Ref directory with all tracks for album elif uri == 'spotifyweb:albums': return self._cache.sortedAlbums # return Ref directory for all albums elif uri.startswith('spotifyweb:featured-playlists') or \ uri.startswith('spotifyweb:new-releases') or \ uri.startswith('spotifyweb:categories') : ids = uri.split(':') webapi_url = 'browse/' + '/'.join(ids[1:]) # we browse the /playlists endpoint for categories if len(ids) == 3 and ids[1] == 'categories': webapi_url += '/playlists' try: offset = 0 arr = [] while True: results = self.sp_webapi()._get(webapi_url, limit=50, offset=offset) if results.has_key('categories'): result_list = results['categories'] arr += [ Ref.directory(uri='spotifyweb:categories:'+cat['id'], name=cat['name']) for cat in result_list['items']] elif results.has_key('playlists'): result_list = results['playlists'] arr += [ Ref.playlist(uri=playlist['uri'], name=playlist['name']) for playlist in result_list['items']] elif results.has_key('albums'): result_list = results['albums'] arr += [ Ref.album(uri=album['uri'], name=album['name']) for album in result_list['items']] if result_list['next'] is None: break offset = len(arr) return arr except spotipy.SpotifyException as e: logger.info('spotipy called failed') return [] else: return []
def test_path_to_ref(): from mopidy.m3u.translator import path_to_ref assert path_to_ref(b'test.m3u') == Ref.playlist( uri='m3u:test.m3u', name='test' ) assert path_to_ref(b'Test Playlist.m3u') == Ref.playlist( uri='m3u:Test%20Playlist.m3u', name='Test Playlist' )
def test_browse_root_returns_dir_ref_for_each_lib_with_root_dir_name(self): result = self.core.library.browse(None) self.assertEqual(result, [ Ref.directory(uri='dummy1:directory', name='dummy1'), Ref.directory(uri='dummy2:directory', name='dummy2'), ]) self.assertFalse(self.library1.browse.called) self.assertFalse(self.library2.browse.called) self.assertFalse(self.backend3.library.browse.called)
def test_repr_without_results(self): self.assertEquals("Ref(name=u'foo', type=u'artist', uri=u'uri')", repr(Ref(uri='uri', name='foo', type='artist')))
def station_to_ref(self, station): return Ref.track( uri='radionet:station:%s' % (station.id), name=station.name, )
def test_serialize_without_results(self): self.assertDictEqual({ '__model__': 'Ref', 'uri': 'uri' }, Ref(uri='uri').serialize())
def create_album(tidal_album): return Ref.album(uri="tidal:album:" + str(tidal_album.id), name=tidal_album.name)
class RadioNetLibraryProvider(backend.LibraryProvider): root_directory = Ref.directory(uri='radionet:root', name='Radio.net') def __init__(self, backend): super().__init__(backend) def lookup(self, uri): if not uri.startswith('radionet:'): return None variant, identifier = self.parse_uri(uri) if variant == 'station': identifier = int(identifier) radio_data = self.backend.radionet.get_station_by_id(identifier) artist = Artist(name=radio_data.name) album = Album( artists=[artist], name=radio_data.description + ' / ' + radio_data.continent + ' / ' + radio_data.country + ' - ' + radio_data.city, uri='radionet:station:%s' % (identifier)) track = Track( artists=[artist], album=album, name=radio_data.name, genre=radio_data.genres, comment=radio_data.description, uri=radio_data.stream_url) return [track] return [] def browse(self, uri): self.backend.refresh() directories = [] tracks = [] variant, identifier = self.parse_uri(uri) if variant == 'root': if self.backend.radionet.local_stations: directories.append( self.ref_directory( "radionet:category:localstations", "Local stations") ) if self.backend.radionet.top_stations: directories.append( self.ref_directory( "radionet:category:top100", "Top 100") ) if self.backend.radionet.favorite_stations: directories.append( self.ref_directory( "radionet:category:favorites", "Favorites") ) return directories elif variant == 'category' and identifier: if identifier == "localstations": for station in self.backend.radionet.local_stations: tracks.append(self.station_to_ref(station)) if identifier == "top100": for station in self.backend.radionet.top_stations: tracks.append(self.station_to_ref(station)) if identifier == "favorites": for station in self.backend.radionet.favorite_stations: tracks.append(self.station_to_ref(station)) tracks.sort(key=lambda ref: ref.name) return tracks else: logger.debug('Unknown URI: %s', uri) return [] def search(self, query=None, uris=None, exact=False): result = [] self.backend.radionet.do_search(' '.join(query['any'])) for station in self.backend.radionet.search_results: result.append(self.station_to_track(station)) return SearchResult( tracks=result ) def station_to_ref(self, station): return Ref.track( uri='radionet:station:%s' % (station.id), name=station.name, ) def station_to_track(self, station): ref = self.station_to_ref(station) return Track(uri=ref.uri, name=ref.name, album=Album(uri=ref.uri, name=ref.name), artists=[Artist(uri=ref.uri, name=ref.name)]) def ref_directory(self, uri, name): return Ref.directory(uri=uri, name=name) def parse_uri(self, uri): result = re.findall(r'^radionet:([a-z]+):?([a-z0-9]+|\d+)?$', uri) if result: return result[0] return None, None
def create_artist(tidal_artist): return Ref.artist(uri="tidal:artist:" + str(tidal_artist.id), name=tidal_artist.name)
def create_mood(tidal_mood): return Ref.playlist(uri="tidal:mood:" + str(tidal_mood.id), name=tidal_mood.name)
def raw_playlist_to_ref(self, playlist): if playlist is None: return None return Ref.playlist(uri=uri.get_playlist_uri(playlist.get('id')), name=playlist.get('name'))
def to_mopidy_playlists(wimpy_playlists): playlists = [] for playlist in wimpy_playlists: playlists.append(Ref.playlist(uri=playlist.id, name=playlist.name)) return playlists
def raw_directory_to_ref(self, directory): if directory is None: return None return Ref.directory(name=directory.get('title') or directory.get('name'), uri=uri.get_directory_uri(directory.get('id')))
def raw_artist_to_ref(self, artist): if artist is None: return None return Ref.artist(name=artist.get('name') or UNKNOWN_ARTIST, uri=uri.get_artist_uri(artist.get('id')))
def raw_album_to_ref(self, album): if album is None: return None return Ref.album(name=album.get('title') or album.get('name') or UNKNOWN_ALBUM, uri=uri.get_album_uri(album.get('id')))
def raw_song_to_ref(self, song): if song is None: return None return Ref.track(name=song.get('title') or UNKNOWN_SONG, uri=uri.get_song_uri(song.get('id')))
def as_list(self): refs = [ Ref.playlist(uri=pl.uri, name=pl.name) for pl in self._playlists.values() ] return sorted(refs, key=operator.attrgetter('name'))
def show_to_ref(show): if show["item"] != "show": logger.debug(f'Expecting show but got {show["item"]}') uri = unparse_uri("episodes", show.get("guide_id", "??")) name = show.get("text", show["URL"]) return Ref.directory(uri=uri, name=name)
def to_mopidy_track_ref(self, track): uri = 'wimpy:track:' + str(track.id) return Ref.track(uri=uri, name=track.name)
def category_to_ref(category): uri = unparse_uri("category", category["key"]) return Ref.directory(uri=uri, name=category["text"])
def local_to_mopidy_track_ref(self, uri): return Ref.track(uri=uri, name=self.tracks[uri].name)
def create_playlist(tidal_playlist): return Ref.playlist(uri="tidal:playlist:" + str(tidal_playlist.id), name=tidal_playlist.name)
def get_items(self, uri): playlist = self._playlists.get(uri) if playlist is None: return None return [Ref.track(uri=t.uri, name=t.name) for t in playlist.tracks]
def create_genre(tidal_genre): return Ref.playlist(uri="tidal:genre:" + str(tidal_genre.id), name=tidal_genre.name)
def test_album_constructor(self): ref = Ref.album(uri='foo', name='bar') self.assertEqual(ref.uri, 'foo') self.assertEqual(ref.name, 'bar') self.assertEqual(ref.type, Ref.ALBUM)
def create_track(tidal_track): uri = "tidal:track:{0}:{1}:{2}".format(tidal_track.artist.id, tidal_track.album.id, tidal_track.id) return Ref.track(uri=uri, name=tidal_track.name)
def test_to_json_and_back(self): ref1 = Ref(uri='uri') serialized = json.dumps(ref1, cls=ModelJSONEncoder) ref2 = json.loads(serialized, object_hook=model_json_decoder) self.assertEqual(ref1, ref2)
def ref_directory(self, uri, name): return Ref.directory(uri=uri, name=name)
def test_directory_constructor(self): ref = Ref.directory(uri='foo', name='bar') self.assertEqual(ref.uri, 'foo') self.assertEqual(ref.name, 'bar') self.assertEqual(ref.type, Ref.DIRECTORY)
def test_artist_constructor(self): ref = Ref.artist(uri='foo', name='bar') self.assertEqual(ref.uri, 'foo') self.assertEqual(ref.name, 'bar') self.assertEqual(ref.type, Ref.ARTIST)
class OE1LibraryProvider(backend.LibraryProvider): root_directory = Ref.directory(uri=OE1Uris.ROOT, name='OE1') root = [ Ref.track(uri=OE1Uris.LIVE, name='Live'), Ref.track(uri=OE1Uris.CAMPUS, name='Campus'), Ref.directory(uri=OE1Uris.ARCHIVE, name='7 Tage') ] def __init__(self, backend, client=OE1Client()): super(OE1LibraryProvider, self).__init__(backend) self.client = client def browse(self, uri): try: library_uri = OE1LibraryUri.parse(uri) except InvalidOE1Uri as e: logger.error(e) return [] if library_uri.uri_type == OE1UriType.ROOT: return self.root if library_uri.uri_type == OE1UriType.ARCHIVE: return self._browse_archive() if library_uri.uri_type == OE1UriType.ARCHIVE_DAY: return self._browse_day(library_uri.day_id) logger.warning('OE1LibraryProvider.browse called with uri ' 'that does not support browsing: \'%s\'.' % uri) return [] def _browse_archive(self): return [ Ref.directory(uri=str( OE1LibraryUri(OE1UriType.ARCHIVE_DAY, day['id'])), name=day['label']) for day in self.client.get_days() ] def _get_track_title(self, item): return '%s: %s' % (item['time'], item['title']) def _browse_day(self, day_id): return [ Ref.track(uri=str( OE1LibraryUri(OE1UriType.ARCHIVE_ITEM, day_id, item['id'])), name=self._get_track_title(item)) for item in self.client.get_day(day_id)['items'] ] def lookup(self, uri): try: library_uri = OE1LibraryUri.parse(uri) except InvalidOE1Uri as e: logger.error(e) return [] if library_uri.uri_type == OE1UriType.LIVE: return [Track(uri=OE1Uris.LIVE, name='Live')] if library_uri.uri_type == OE1UriType.CAMPUS: return [Track(uri=OE1Uris.CAMPUS, name='Campus')] if library_uri.uri_type == OE1UriType.ARCHIVE_DAY: return self._browse_day(library_uri.day_id) if library_uri.uri_type == OE1UriType.ARCHIVE_ITEM: return self._lookup_item(library_uri.day_id, library_uri.item_id) logger.warning('OE1LibraryProvider.lookup called with uri ' 'that does not support lookup: \'%s\'.' % uri) return [] def _lookup_item(self, day_id, item_id): item = self.client.get_item(day_id, item_id) return [ Track(uri=str( OE1LibraryUri(OE1UriType.ARCHIVE_ITEM, day_id, item['id'])), name=self._get_track_title(item)) ] def refresh(self, uri=None): self.client.refresh()
def test_playlist_constructor(self): ref = Ref.playlist(uri='foo', name='bar') self.assertEqual(ref.uri, 'foo') self.assertEqual(ref.name, 'bar') self.assertEqual(ref.type, Ref.PLAYLIST)
def _browse_archive(self): return [ Ref.directory(uri=str( OE1LibraryUri(OE1UriType.ARCHIVE_DAY, day['id'])), name=day['label']) for day in self.client.get_days() ]