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())
Exemple #3
0
    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
Exemple #5
0
    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])
Exemple #6
0
    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))
Exemple #8
0
    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')
    ]
Exemple #10
0
    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])
Exemple #11
0
    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)")
Exemple #13
0
    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]")
Exemple #14
0
    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)
Exemple #15
0
    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')
    ]
Exemple #18
0
    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)
Exemple #20
0
    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)
Exemple #21
0
    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')
Exemple #22
0
    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')
Exemple #23
0
    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]')
Exemple #24
0
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)
Exemple #25
0
    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')
        ]
Exemple #27
0
    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'
    )
Exemple #30
0
    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)
Exemple #31
0
 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,
     )
Exemple #33
0
 def test_serialize_without_results(self):
     self.assertDictEqual({
         '__model__': 'Ref',
         'uri': 'uri'
     },
                          Ref(uri='uri').serialize())
Exemple #34
0
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
Exemple #36
0
def create_artist(tidal_artist):
    return Ref.artist(uri="tidal:artist:" + str(tidal_artist.id),
                      name=tidal_artist.name)
Exemple #37
0
def create_mood(tidal_mood):
    return Ref.playlist(uri="tidal:mood:" + str(tidal_mood.id),
                        name=tidal_mood.name)
Exemple #38
0
 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'))
Exemple #39
0
def to_mopidy_playlists(wimpy_playlists):
    playlists = []
    for playlist in wimpy_playlists:
        playlists.append(Ref.playlist(uri=playlist.id, name=playlist.name))
    return playlists
Exemple #40
0
 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')))
Exemple #41
0
 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')))
Exemple #42
0
 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')))
Exemple #43
0
 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')))
Exemple #44
0
 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)
Exemple #46
0
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"])
Exemple #48
0
def local_to_mopidy_track_ref(self, uri):

    return Ref.track(uri=uri, name=self.tracks[uri].name)
Exemple #49
0
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]
Exemple #51
0
def create_genre(tidal_genre):
    return Ref.playlist(uri="tidal:genre:" + str(tidal_genre.id),
                        name=tidal_genre.name)
Exemple #52
0
 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)
Exemple #53
0
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)
Exemple #54
0
 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)
Exemple #56
0
 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)
Exemple #57
0
 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)
Exemple #58
0
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()
Exemple #59
0
 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)
Exemple #60
0
 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()
     ]