Example #1
0
def _lookup_artist(config, sp_link):
    sp_artist = sp_link.as_artist()
    sp_artist_browser = sp_artist.browse(
        type=spotify.ArtistBrowserType.NO_TRACKS)
    sp_artist_browser.load(config["timeout"])

    # Get all album browsers we need first, so they can start retrieving
    # data in the background.
    sp_album_browsers = []
    for sp_album in sp_artist_browser.albums:
        sp_album.load(config["timeout"])
        if not sp_album.is_available:
            continue
        if sp_album.type is spotify.AlbumType.COMPILATION:
            continue
        if sp_album.artist.link.uri in _VARIOUS_ARTISTS_URIS:
            continue
        sp_album_browsers.append(sp_album.browse())

    for sp_album_browser in sp_album_browsers:
        sp_album_browser.load(config["timeout"])
        for sp_track in sp_album_browser.tracks:
            track = translator.to_track(sp_track, bitrate=config["bitrate"])
            if track is not None:
                yield track
Example #2
0
def _lookup_playlist(config, sp_link):
    sp_playlist = sp_link.as_playlist()
    sp_playlist.load()
    for sp_track in sp_playlist.tracks:
        track = translator.to_track(sp_track, bitrate=config['bitrate'])
        if track is not None:
            yield track
Example #3
0
def _lookup_artist(config, sp_link):
    sp_artist = sp_link.as_artist()
    sp_artist_browser = sp_artist.browse(
        type=spotify.ArtistBrowserType.NO_TRACKS)
    sp_artist_browser.load(config['timeout'])

    # Get all album browsers we need first, so they can start retrieving
    # data in the background.
    sp_album_browsers = []
    for sp_album in sp_artist_browser.albums:
        sp_album.load(config['timeout'])
        if not sp_album.is_available:
            continue
        if sp_album.type is spotify.AlbumType.COMPILATION:
            continue
        if sp_album.artist.link.uri in _VARIOUS_ARTISTS_URIS:
            continue
        sp_album_browsers.append(sp_album.browse())

    for sp_album_browser in sp_album_browsers:
        sp_album_browser.load(config['timeout'])
        for sp_track in sp_album_browser.tracks:
            track = translator.to_track(
                sp_track, bitrate=config['bitrate'])
            if track is not None:
                yield track
Example #4
0
def _lookup_playlist(config, sp_link):
    sp_playlist = sp_link.as_playlist()
    sp_playlist.load()
    for sp_track in sp_playlist.tracks:
        track = translator.to_track(
            sp_track, bitrate=config['bitrate'])
        if track is not None:
            yield track
Example #5
0
def _lookup_album(config, sp_link):
    sp_album = sp_link.as_album()
    sp_album_browser = sp_album.browse()
    sp_album_browser.load(config["timeout"])
    for sp_track in sp_album_browser.tracks:
        track = translator.to_track(sp_track, bitrate=config["bitrate"])
        if track is not None:
            yield track
Example #6
0
    def test_successful_translation(self, sp_track_mock, sp_playlist_mock):
        track = translator.to_track(sp_track_mock)
        playlist = translator.to_playlist(sp_playlist_mock)

        assert playlist.uri == 'spotify:user:alice:playlist:foo'
        assert playlist.name == 'Foo'
        assert playlist.length == 1
        assert track in playlist.tracks
        assert playlist.last_modified is None
Example #7
0
    def test_successful_translation(self, sp_track_mock, sp_playlist_mock):
        track = translator.to_track(sp_track_mock)
        playlist = translator.to_playlist(sp_playlist_mock)

        assert playlist.uri == 'spotify:user:alice:playlist:foo'
        assert playlist.name == 'Foo'
        assert playlist.length == 1
        assert track in playlist.tracks
        assert playlist.last_modified is None
Example #8
0
    def test_returns_none_if_error(self, sp_track_mock, caplog):
        sp_track_mock.error = spotify.ErrorType.OTHER_PERMANENT

        track = translator.to_track(sp_track_mock)

        assert track is None
        assert (
            'Error loading spotify:track:abc: <ErrorType.OTHER_PERMANENT: 10>'
            in caplog.text())
Example #9
0
def _lookup_album(config, sp_link):
    sp_album = sp_link.as_album()
    sp_album_browser = sp_album.browse()
    sp_album_browser.load(config['timeout'])
    for sp_track in sp_album_browser.tracks:
        track = translator.to_track(
            sp_track, bitrate=config['bitrate'])
        if track is not None:
            yield track
Example #10
0
    def test_returns_none_if_error(self, sp_track_mock, caplog):
        sp_track_mock.error = spotify.ErrorType.OTHER_PERMANENT

        track = translator.to_track(sp_track_mock)

        assert track is None
        assert (
            'Error loading spotify:track:abc: <ErrorType.OTHER_PERMANENT: 10>'
            in caplog.text())
Example #11
0
    def test_successful_translation(self, sp_track_mock):
        track = translator.to_track(sp_track_mock, bitrate=320)

        assert track.uri == 'spotify:track:abc'
        assert track.name == 'ABC 123'
        assert list(track.artists) == [
            models.Artist(uri='spotify:artist:abba', name='ABBA')]
        assert track.album == models.Album(
            uri='spotify:album:def',
            name='DEF 456',
            artists=[
                models.Artist(uri='spotify:artist:abba', name='ABBA')],
            date='2001')
        assert track.track_no == 7
        assert track.disc_no == 1
        assert track.date == '2001'
        assert track.length == 174300
        assert track.bitrate == 320
Example #12
0
    def test_successful_translation(self, sp_track_mock):
        track = translator.to_track(sp_track_mock, bitrate=320)

        assert track.uri == 'spotify:track:abc'
        assert track.name == 'ABC 123'
        assert list(track.artists) == [
            models.Artist(uri='spotify:artist:abba', name='ABBA')
        ]
        assert track.album == models.Album(
            uri='spotify:album:def',
            name='DEF 456',
            artists=[models.Artist(uri='spotify:artist:abba', name='ABBA')],
            date='2001')
        assert track.track_no == 7
        assert track.disc_no == 1
        assert track.date == '2001'
        assert track.length == 174300
        assert track.bitrate == 320
Example #13
0
    def test_successful_translation(self, sp_track_mock):
        track = translator.to_track(sp_track_mock, bitrate=320)

        assert track.uri == "spotify:track:abc"
        assert track.name == "ABC 123"
        assert list(track.artists) == [
            models.Artist(uri="spotify:artist:abba", name="ABBA")
        ]
        assert track.album == models.Album(
            uri="spotify:album:def",
            name="DEF 456",
            artists=[models.Artist(uri="spotify:artist:abba", name="ABBA")],
            date="2001",
        )
        assert track.track_no == 7
        assert track.disc_no == 1
        assert track.date == "2001"
        assert track.length == 174300
        assert track.bitrate == 320
Example #14
0
def search(config, session, query=None, uris=None, exact=False):
    # TODO Respect `uris` argument
    # TODO Support `exact` search

    if query is None:
        logger.debug('Ignored search without query')
        return models.SearchResult(uri='spotify:search')

    if 'uri' in query:
        return _search_by_uri(config, session, query)

    sp_query = translator.sp_search_query(query)
    if not sp_query:
        logger.debug('Ignored search with empty query')
        return models.SearchResult(uri='spotify:search')

    uri = 'spotify:search:%s' % urllib.quote(sp_query.encode('utf-8'))
    logger.info('Searching Spotify for: %s', sp_query)

    if session.connection.state is not spotify.ConnectionState.LOGGED_IN:
        logger.info('Spotify search aborted: Spotify is offline')
        return models.SearchResult(uri=uri)

    sp_search = session.search(sp_query,
                               album_count=config['search_album_count'],
                               artist_count=config['search_artist_count'],
                               track_count=config['search_track_count'])
    sp_search.load()

    albums = [translator.to_album(sp_album) for sp_album in sp_search.albums]
    artists = [
        translator.to_artist(sp_artist) for sp_artist in sp_search.artists
    ]
    tracks = [translator.to_track(sp_track) for sp_track in sp_search.tracks]

    return models.SearchResult(uri=uri,
                               albums=albums,
                               artists=artists,
                               tracks=tracks)
Example #15
0
def search(config, session, query=None, uris=None, exact=False):
    # TODO Respect `uris` argument
    # TODO Support `exact` search

    if query is None:
        logger.debug('Ignored search without query')
        return models.SearchResult(uri='spotify:search')

    if 'uri' in query:
        return _search_by_uri(config, session, query)

    sp_query = translator.sp_search_query(query)
    if not sp_query:
        logger.debug('Ignored search with empty query')
        return models.SearchResult(uri='spotify:search')

    uri = 'spotify:search:%s' % urllib.quote(sp_query.encode('utf-8'))
    logger.info('Searching Spotify for: %s', sp_query)

    if session.connection.state is not spotify.ConnectionState.LOGGED_IN:
        logger.info('Spotify search aborted: Spotify is offline')
        return models.SearchResult(uri=uri)

    sp_search = session.search(
        sp_query,
        album_count=config['search_album_count'],
        artist_count=config['search_artist_count'],
        track_count=config['search_track_count'])
    sp_search.load()

    albums = [
        translator.to_album(sp_album) for sp_album in sp_search.albums]
    artists = [
        translator.to_artist(sp_artist) for sp_artist in sp_search.artists]
    tracks = [
        translator.to_track(sp_track) for sp_track in sp_search.tracks]

    return models.SearchResult(
        uri=uri, albums=albums, artists=artists, tracks=tracks)
Example #16
0
    def test_returns_none_if_unloaded(self, sp_track_mock):
        sp_track_mock.is_loaded = False

        track = translator.to_track(sp_track_mock)

        assert track is None
Example #17
0
    def test_returns_none_if_unloaded(self, sp_track_mock):
        sp_track_mock.is_loaded = False

        track = translator.to_track(sp_track_mock)

        assert track is None
Example #18
0
    def test_returns_none_if_not_available(self, sp_track_mock):
        sp_track_mock.availability = spotify.TrackAvailability.UNAVAILABLE

        track = translator.to_track(sp_track_mock)

        assert track is None
Example #19
0
def _lookup_track(config, sp_link):
    sp_track = sp_link.as_track()
    sp_track.load(config['timeout'])
    track = translator.to_track(sp_track, bitrate=config['bitrate'])
    if track is not None:
        yield track
Example #20
0
def _lookup_track(config, sp_link):
    sp_track = sp_link.as_track()
    sp_track.load(config["timeout"])
    track = translator.to_track(sp_track, bitrate=config["bitrate"])
    if track is not None:
        yield track
Example #21
0
    def test_filters_out_none_artists(self, sp_artist_mock, sp_track_mock):
        sp_artist_mock.is_loaded = False

        track = translator.to_track(sp_track_mock)

        assert list(track.artists) == []
Example #22
0
    def test_caches_results(self, sp_track_mock):
        track1 = translator.to_track(sp_track_mock)
        track2 = translator.to_track(sp_track_mock)

        assert track1 is track2
Example #23
0
    def test_caches_results(self, sp_track_mock):
        track1 = translator.to_track(sp_track_mock)
        track2 = translator.to_track(sp_track_mock)

        assert track1 is track2
Example #24
0
    def test_filters_out_none_artists(self, sp_artist_mock, sp_track_mock):
        sp_artist_mock.is_loaded = False

        track = translator.to_track(sp_track_mock)

        assert list(track.artists) == []
Example #25
0
def _lookup_track(config, sp_link):
    sp_track = sp_link.as_track()
    sp_track.load()
    track = translator.to_track(sp_track, bitrate=config['bitrate'])
    if track is not None:
        yield track
Example #26
0
    def test_returns_none_if_not_available(self, sp_track_mock):
        sp_track_mock.availability = spotify.TrackAvailability.UNAVAILABLE

        track = translator.to_track(sp_track_mock)

        assert track is None