def __init__(self, session, sp_playlistcontainer, sp_playlist):
self._session = session
lib.sp_playlistcontainer_add_ref(sp_playlistcontainer)
self._sp_playlistcontainer = ffi.gc(sp_playlistcontainer, lib.sp_playlistcontainer_release)
lib.sp_playlist_add_ref(sp_playlist)
self._sp_playlist = ffi.gc(sp_playlist, lib.sp_playlist_release)
self._num_tracks = 0
self._sp_tracks_len = 0
self._get_more_tracks()
def __init__(self, config=None):
super(Session, self).__init__()
if spotify._session_instance is not None:
raise RuntimeError('Session has already been initialized')
if config is not None:
self.config = config
else:
self.config = spotify.Config()
if self.config.application_key is None:
self.config.load_application_key_file()
sp_session_ptr = ffi.new('sp_session **')
spotify.Error.maybe_raise(lib.sp_session_create(
self.config._sp_session_config, sp_session_ptr))
self._sp_session = ffi.gc(sp_session_ptr[0], lib.sp_session_release)
self._cache = weakref.WeakValueDictionary()
self._emitters = []
self._callback_handles = set()
self.connection = spotify.connection.Connection(self)
self.offline = spotify.offline.Offline(self)
self.player = spotify.player.Player(self)
self.social = spotify.social.Social(self)
spotify._session_instance = self
def __init__(
self, session, uri=None, sp_image=None, add_ref=True,
callback=None):
assert uri or sp_image, 'uri or sp_image is required'
self._session = session
if uri is not None:
image = spotify.Link(self._session, uri=uri).as_image()
if image is None:
raise ValueError(
'Failed to get image from Spotify URI: %r' % uri)
sp_image = image._sp_image
add_ref = True
if add_ref:
lib.sp_image_add_ref(sp_image)
self._sp_image = ffi.gc(sp_image, lib.sp_image_release)
self.loaded_event = threading.Event()
handle = ffi.new_handle((self._session, self, callback))
self._session._callback_handles.add(handle)
spotify.Error.maybe_raise(lib.sp_image_add_load_callback(
self._sp_image, _image_load_callback, handle))
def __init__(
self, session, type=None, region=None, canonical_username=None,
callback=None, sp_toplistbrowse=None, add_ref=True):
assert (type is not None and region is not None) or sp_toplistbrowse, \
'type and region, or sp_toplistbrowse, is required'
self._session = session
self.type = type
self.region = region
self.canonical_username = canonical_username
self.loaded_event = threading.Event()
if sp_toplistbrowse is None:
if isinstance(region, ToplistRegion):
region = int(region)
else:
region = utils.to_country_code(region)
handle = ffi.new_handle((self._session, self, callback))
self._session._callback_handles.add(handle)
sp_toplistbrowse = lib.sp_toplistbrowse_create(
self._session._sp_session, int(type), region,
utils.to_char_or_null(canonical_username),
_toplistbrowse_complete_callback, handle)
add_ref = False
if add_ref:
lib.sp_toplistbrowse_add_ref(sp_toplistbrowse)
self._sp_toplistbrowse = ffi.gc(
sp_toplistbrowse, lib.sp_toplistbrowse_release)
def __init__(
self, sp_obj, add_ref_func, release_func, len_func, getitem_func):
add_ref_func(sp_obj)
self._sp_obj = ffi.gc(sp_obj, release_func)
self._len_func = len_func
self._getitem_func = getitem_func
def __init__(
self, session, artist=None, type=None, callback=None,
sp_artistbrowse=None, add_ref=True):
assert artist or sp_artistbrowse, (
'artist or sp_artistbrowse is required')
self._session = session
self.loaded_event = threading.Event()
if sp_artistbrowse is None:
if type is None:
type = ArtistBrowserType.FULL
handle = ffi.new_handle((self._session, self, callback))
self._session._callback_handles.add(handle)
sp_artistbrowse = lib.sp_artistbrowse_create(
self._session._sp_session, artist._sp_artist,
int(type), _artistbrowse_complete_callback, handle)
add_ref = False
if add_ref:
lib.sp_artistbrowse_add_ref(sp_artistbrowse)
self._sp_artistbrowse = ffi.gc(
sp_artistbrowse, lib.sp_artistbrowse_release)
def __init__(
self, session, canonical_username=None, tracks=None, message='',
callback=None, sp_inbox=None, add_ref=True):
assert canonical_username and tracks or sp_inbox, \
'canonical_username and tracks, or sp_inbox, is required'
self._session = session
self.loaded_event = threading.Event()
if sp_inbox is None:
canonical_username = utils.to_char(canonical_username)
if isinstance(tracks, spotify.Track):
tracks = [tracks]
message = utils.to_char(message)
handle = ffi.new_handle((self._session, self, callback))
self._session._callback_handles.add(handle)
sp_inbox = lib.sp_inbox_post_tracks(
self._session._sp_session, canonical_username,
[t._sp_track for t in tracks], len(tracks),
message, _inboxpost_complete_callback, handle)
add_ref = True
if sp_inbox == ffi.NULL:
raise spotify.Error('Inbox post request failed to initialize')
if add_ref:
lib.sp_inbox_add_ref(sp_inbox)
self._sp_inbox = ffi.gc(sp_inbox, lib.sp_inbox_release)
def __init__(self, session, sp_playlist, index):
self._session = session
lib.sp_playlist_add_ref(sp_playlist)
self._sp_playlist = ffi.gc(sp_playlist, lib.sp_playlist_release)
self._index = index
def __init__(self, session, uri=None, sp_playlist=None, add_ref=True):
super(Playlist, self).__init__()
assert uri or sp_playlist, 'uri or sp_playlist is required'
self._session = session
if uri is not None:
playlist = spotify.Link(self._session, uri).as_playlist()
if playlist is None:
raise spotify.Error(
'Failed to get playlist from Spotify URI: %r' % uri)
sp_playlist = playlist._sp_playlist
session._cache[sp_playlist] = self
add_ref = True
if add_ref:
lib.sp_playlist_add_ref(sp_playlist)
self._sp_playlist = ffi.gc(sp_playlist, lib.sp_playlist_release)
self._sp_playlist_callbacks = _PlaylistCallbacks.get_struct()
lib.sp_playlist_add_callbacks(
self._sp_playlist, self._sp_playlist_callbacks, ffi.NULL)
# Make sure we remove callbacks in __del__() using the same lib as we
# added callbacks with.
self._lib = lib
def __init__(self, session, sp_playlistcontainer, add_ref=True):
super(PlaylistContainer, self).__init__()
self._session = session
if add_ref:
lib.sp_playlistcontainer_add_ref(sp_playlistcontainer)
self._sp_playlistcontainer = ffi.gc(
sp_playlistcontainer, lib.sp_playlistcontainer_release)
self._sp_playlistcontainer_callbacks = None
# Make sure we remove callbacks in __del__() using the same lib as we
# added callbacks with.
self._lib = lib
def __init__(self, session, uri=None, sp_artist=None, add_ref=True):
assert uri or sp_artist, 'uri or sp_artist is required'
self._session = session
if uri is not None:
artist = spotify.Link(self._session, uri=uri).as_artist()
if artist is None:
raise ValueError(
'Failed to get artist from Spotify URI: %r' % uri)
sp_artist = artist._sp_artist
if add_ref:
lib.sp_artist_add_ref(sp_artist)
self._sp_artist = ffi.gc(sp_artist, lib.sp_artist_release)
def __init__(self, session, uri=None, sp_album=None, add_ref=True):
assert uri or sp_album, 'uri or sp_album is required'
self._session = session
if uri is not None:
album = spotify.Link(self._session, uri=uri).as_album()
if album is None:
raise ValueError(
'Failed to get album from Spotify URI: %r' % uri)
sp_album = album._sp_album
add_ref = True
if add_ref:
lib.sp_album_add_ref(sp_album)
self._sp_album = ffi.gc(sp_album, lib.sp_album_release)
def __init__(self, session, uri=None, sp_user=None, add_ref=True):
assert uri or sp_user, 'uri or sp_user is required'
self._session = session
if uri is not None:
user = spotify.Link(self._session, uri=uri).as_user()
if user is None:
raise ValueError(
'Failed to get user from Spotify URI: %r' % uri)
sp_user = user._sp_user
add_ref = True
if add_ref:
lib.sp_user_add_ref(sp_user)
self._sp_user = ffi.gc(sp_user, lib.sp_user_release)
def __init__(self, session, uri=None, sp_link=None, add_ref=True):
assert uri or sp_link, 'uri or sp_link is required'
self._session = session
if uri is not None:
sp_link = lib.sp_link_create_from_string(
utils.to_char(Link._normalize_uri(uri)))
add_ref = False
if sp_link == ffi.NULL:
raise ValueError(
'Failed to get link from Spotify URI: %r' % uri)
if add_ref:
lib.sp_link_add_ref(sp_link)
self._sp_link = ffi.gc(sp_link, lib.sp_link_release)
def __init__(self, session, uri=None, sp_track=None, add_ref=True):
assert uri or sp_track, 'uri or sp_track is required'
self._session = session
if uri is not None:
track = spotify.Link(self._session, uri=uri).as_track()
if track is None:
raise ValueError(
'Failed to get track from Spotify URI: %r' % uri)
sp_track = track._sp_track
add_ref = True
if add_ref:
lib.sp_track_add_ref(sp_track)
self._sp_track = ffi.gc(sp_track, lib.sp_track_release)
def __init__(
self,
session,
canonical_username=None,
tracks=None,
message='',
callback=None,
sp_inbox=None,
add_ref=True,
):
assert (
canonical_username and tracks or sp_inbox
), 'canonical_username and tracks, or sp_inbox, is required'
self._session = session
self.loaded_event = threading.Event()
if sp_inbox is None:
canonical_username = utils.to_char(canonical_username)
if isinstance(tracks, spotify.Track):
tracks = [tracks]
message = utils.to_char(message)
handle = ffi.new_handle((self._session, self, callback))
self._session._callback_handles.add(handle)
sp_inbox = lib.sp_inbox_post_tracks(
self._session._sp_session,
canonical_username,
[t._sp_track for t in tracks],
len(tracks),
message,
_inboxpost_complete_callback,
handle,
)
add_ref = True
if sp_inbox == ffi.NULL:
raise spotify.Error('Inbox post request failed to initialize')
if add_ref:
lib.sp_inbox_add_ref(sp_inbox)
self._sp_inbox = ffi.gc(sp_inbox, lib.sp_inbox_release)
def subscribers(self):
"""The canonical usernames of up to 500 of the subscribers of the
playlist.
May be empty until you call :meth:`update_subscribers` and the
:attr:`~PlaylistEvent.SUBSCRIBERS_CHANGED` event is emitted from the
playlist.
"""
sp_subscribers = ffi.gc(lib.sp_playlist_subscribers(self._sp_playlist),
lib.sp_playlist_subscribers_free)
# The ``subscribers`` field is ``char *[1]`` according to the struct,
# so we must cast it to ``char **`` to be able to access more than the
# first subscriber.
subscribers = ffi.cast('char **', sp_subscribers.subscribers)
usernames = []
for i in range(sp_subscribers.count):
usernames.append(utils.to_unicode(subscribers[i]))
return usernames
def __init__(self, session, uri=None, sp_link=None, add_ref=True):
assert uri or sp_link, 'uri or sp_link is required'
self._session = session
if uri is not None:
sp_link = lib.sp_link_create_from_string(
utils.to_char(Link._normalize_uri(uri))
)
add_ref = False
if sp_link == ffi.NULL:
raise ValueError(
'Failed to get link from Spotify URI: %r' % uri
)
if add_ref:
lib.sp_link_add_ref(sp_link)
self._sp_link = ffi.gc(sp_link, lib.sp_link_release)
def __init__(
self, session, query='', callback=None,
track_offset=0, track_count=20,
album_offset=0, album_count=20,
artist_offset=0, artist_count=20,
playlist_offset=0, playlist_count=20,
search_type=None,
sp_search=None, add_ref=True):
assert query or sp_search, 'query or sp_search is required'
self._session = session
self.callback = callback
self.track_offset = track_offset
self.track_count = track_count
self.album_offset = album_offset
self.album_count = album_count
self.artist_offset = artist_offset
self.artist_count = artist_count
self.playlist_offset = playlist_offset
self.playlist_count = playlist_count
if search_type is None:
search_type = SearchType.STANDARD
self.search_type = search_type
self.loaded_event = threading.Event()
if sp_search is None:
handle = ffi.new_handle((self._session, self, callback))
self._session._callback_handles.add(handle)
sp_search = lib.sp_search_create(
self._session._sp_session, utils.to_char(query),
track_offset, track_count,
album_offset, album_count,
artist_offset, artist_count,
playlist_offset, playlist_count,
int(search_type), _search_complete_callback, handle)
add_ref = False
if add_ref:
lib.sp_search_add_ref(sp_search)
self._sp_search = ffi.gc(sp_search, lib.sp_search_release)
def __init__(self, session, sp_playlistcontainer, add_ref=True):
super(PlaylistContainer, self).__init__()
self._session = session
if add_ref:
lib.sp_playlistcontainer_add_ref(sp_playlistcontainer)
self._sp_playlistcontainer = ffi.gc(sp_playlistcontainer,
lib.sp_playlistcontainer_release)
self._sp_playlistcontainer_callbacks = (
_PlaylistContainerCallbacks.get_struct())
lib.sp_playlistcontainer_add_callbacks(
self._sp_playlistcontainer, self._sp_playlistcontainer_callbacks,
ffi.NULL)
# Make sure we remove callbacks in __del__() using the same lib as we
# added callbacks with.
self._lib = lib
def __init__(
self,
session,
type=None,
region=None,
canonical_username=None,
callback=None,
sp_toplistbrowse=None,
add_ref=True,
):
assert (type is not None and region is not None) or sp_toplistbrowse, (
'type and region, or sp_toplistbrowse, is required')
self._session = session
self.type = type
self.region = region
self.canonical_username = canonical_username
self.loaded_event = threading.Event()
if sp_toplistbrowse is None:
if isinstance(region, ToplistRegion):
region = int(region)
else:
region = utils.to_country_code(region)
handle = ffi.new_handle((self._session, self, callback))
self._session._callback_handles.add(handle)
sp_toplistbrowse = lib.sp_toplistbrowse_create(
self._session._sp_session,
int(type),
region,
utils.to_char_or_null(canonical_username),
_toplistbrowse_complete_callback,
handle,
)
add_ref = False
if add_ref:
lib.sp_toplistbrowse_add_ref(sp_toplistbrowse)
self._sp_toplistbrowse = ffi.gc(sp_toplistbrowse,
lib.sp_toplistbrowse_release)
def subscribers(self):
"""The canonical usernames of up to 500 of the subscribers of the
playlist.
May be empty until you call :meth:`update_subscribers` and the
:attr:`~PlaylistEvent.SUBSCRIBERS_CHANGED` event is emitted from the
playlist.
"""
sp_subscribers = ffi.gc(
lib.sp_playlist_subscribers(self._sp_playlist),
lib.sp_playlist_subscribers_free)
# The ``subscribers`` field is ``char *[1]`` according to the struct,
# so we must cast it to ``char **`` to be able to access more than the
# first subscriber.
subscribers = ffi.cast('char **', sp_subscribers.subscribers)
usernames = []
for i in range(sp_subscribers.count):
usernames.append(utils.to_unicode(subscribers[i]))
return usernames
def __init__(self,
type=None,
region=None,
canonical_username=None,
callback=None,
sp_toplistbrowse=None,
add_ref=True):
assert (type is not None and region is not None) or sp_toplistbrowse, \
'type and region, or sp_toplistbrowse, is required'
# TODO Document these attributes?
self.type = type
self.region = region
self.canonical_username = canonical_username
self.complete_event = threading.Event()
self._callback_handles = set()
if sp_toplistbrowse is None:
if isinstance(region, ToplistRegion):
region = int(region)
else:
region = utils.to_country_code(region)
handle = ffi.new_handle((callback, self))
# TODO Think through the life cycle of the handle object. Can it
# happen that we GC the search and handle object, and then later
# the callback is called?
self._callback_handles.add(handle)
sp_toplistbrowse = lib.sp_toplistbrowse_create(
spotify.session_instance._sp_session, int(type), region,
utils.to_char_or_null(canonical_username),
_toplistbrowse_complete_callback, handle)
add_ref = False
if add_ref:
lib.sp_toplistbrowse_add_ref(sp_toplistbrowse)
self._sp_toplistbrowse = ffi.gc(sp_toplistbrowse,
lib.sp_toplistbrowse_release)
def __init__(self,
canonical_username=None,
tracks=None,
message='',
callback=None,
sp_inbox=None,
add_ref=True):
assert canonical_username and tracks or sp_inbox, \
'canonical_username and tracks, or sp_inbox, is required'
self.complete_event = threading.Event()
self._callback_handles = set()
if sp_inbox is None:
canonical_username = utils.to_char(canonical_username)
if isinstance(tracks, spotify.Track):
tracks = [tracks]
message = utils.to_char(message)
handle = ffi.new_handle((callback, self))
# TODO Think through the life cycle of the handle object. Can it
# happen that we GC the search and handle object, and then later
# the callback is called?
self._callback_handles.add(handle)
sp_inbox = lib.sp_inbox_post_tracks(
spotify.session_instance._sp_session, canonical_username,
[t._sp_track for t in tracks], len(tracks), message,
_inboxpost_complete_callback, handle)
add_ref = True
if sp_inbox == ffi.NULL:
raise spotify.Error('Inbox post request failed to initialize')
if add_ref:
lib.sp_inbox_add_ref(sp_inbox)
self._sp_inbox = ffi.gc(sp_inbox, lib.sp_inbox_release)
def __init__(
self, session, album=None, callback=None,
sp_albumbrowse=None, add_ref=True):
assert album or sp_albumbrowse, 'album or sp_albumbrowse is required'
self._session = session
self.loaded_event = threading.Event()
if sp_albumbrowse is None:
handle = ffi.new_handle((self._session, self, callback))
self._session._callback_handles.add(handle)
sp_albumbrowse = lib.sp_albumbrowse_create(
self._session._sp_session, album._sp_album,
_albumbrowse_complete_callback, handle)
add_ref = False
if add_ref:
lib.sp_albumbrowse_add_ref(sp_albumbrowse)
self._sp_albumbrowse = ffi.gc(
sp_albumbrowse, lib.sp_albumbrowse_release)
def __init__(self, session, uri=None, sp_playlist=None, add_ref=True):
super(Playlist, self).__init__()
assert uri or sp_playlist, 'uri or sp_playlist is required'
self._session = session
if uri is not None:
sp_playlist = spotify.Link(self._session, uri)._as_sp_playlist()
if sp_playlist is None:
raise spotify.Error(
'Failed to get playlist from Spotify URI: %r' % uri)
session._cache[sp_playlist] = self
add_ref = False
if add_ref:
lib.sp_playlist_add_ref(sp_playlist)
self._sp_playlist = ffi.gc(sp_playlist, lib.sp_playlist_release)
self._sp_playlist_callbacks = None
# Make sure we remove callbacks in __del__() using the same lib as we
# added callbacks with.
self._lib = lib
