def __init__(self, args): threading.Thread.__init__(self) # initialize progress meter self.progress = Progress(args, self) self.args = args # initially logged-out self.logged_out.set() config = spotify.Config() default_dir = default_settings_dir() self.post = PostActions(args, self) self.web = WebAPI(args, self) proxy = os.environ.get('http_proxy') if proxy is not None: config.proxy = proxy # application key location if args.key is not None: config.load_application_key_file(args.key[0]) else: if not path_exists(default_dir): os.makedirs(enc_str(default_dir)) app_key_path = os.path.join(default_dir, "spotify_appkey.key") if not path_exists(app_key_path): print("\n" + Fore.YELLOW + "Please copy your spotify_appkey.key to " + default_dir + ", or use the --key|-k option" + Fore.RESET) sys.exit(1) config.load_application_key_file(app_key_path) # settings directory if args.settings is not None: settings_dir = norm_path(args.settings[0]) config.settings_location = settings_dir config.cache_location = settings_dir else: config.settings_location = default_dir config.cache_location = default_dir self.session = spotify.Session(config=config) self.session.volume_normalization = args.normalize # disable scrobbling self.session.social.set_scrobbling( spotify.SocialProvider.SPOTIFY, spotify.ScrobblingState.LOCAL_DISABLED) self.session.social.set_scrobbling( spotify.SocialProvider.FACEBOOK, spotify.ScrobblingState.LOCAL_DISABLED) self.session.social.set_scrobbling( spotify.SocialProvider.LASTFM, spotify.ScrobblingState.LOCAL_DISABLED) bit_rates = dict([('160', BitRate.BITRATE_160K), ('320', BitRate.BITRATE_320K), ('96', BitRate.BITRATE_96K)]) self.session.preferred_bitrate(bit_rates[args.quality]) self.session.on(spotify.SessionEvent.CONNECTION_STATE_UPDATED, self.on_connection_state_changed) self.session.on(spotify.SessionEvent.END_OF_TRACK, self.on_end_of_track) self.session.on(spotify.SessionEvent.MUSIC_DELIVERY, self.on_music_delivery) self.session.on(spotify.SessionEvent.PLAY_TOKEN_LOST, self.play_token_lost) self.session.on(spotify.SessionEvent.LOGGED_IN, self.on_logged_in) self.event_loop = EventLoop(self.session, 0.1, self)
print('Logged in as') print(bot.user.name) print(bot.user.id) print('------') # SETUP # logged_in_event = threading.Event() def connection_state_listener(session): if session.connection.state is spotify.ConnectionState.LOGGED_IN: logged_in_event.set() session = spotify.Session() loop = spotify.EventLoop(session) loop.start() session.on(spotify.SessionEvent.CONNECTION_STATE_UPDATED, connection_state_listener) session.login(config.user, config.secret) logged_in_event.wait() print(session.user) session.preferred_bitrate(spotify.Bitrate.BITRATE_320k) playlist = ClearQueue() bot.add_cog(search.Search(bot, session, playlist)) bot.add_cog(music.Music(bot, session, playlist))
def __init__(self, args): threading.Thread.__init__(self) # set to a daemon thread self.daemon = True # initialize progress meter self.progress = Progress(args, self) self.args = args self.logged_in = threading.Event() self.logged_out = threading.Event() self.logged_out.set() config = spotify.Config() default_dir = default_settings_dir() # create a log file for rip failures if args.fail_log is not None: _base_dir = base_dir(args) if not os.path.exists(_base_dir): os.makedirs(_base_dir) encoding = "ascii" if args.ascii else "utf-8" self.fail_log_file = codecs.open(os.path.join( _base_dir, args.fail_log[0]), 'w', encoding) # application key location if args.key is not None: config.load_application_key_file(args.key[0]) else: if not os.path.exists(default_dir): os.makedirs(default_dir) app_key_path = os.path.join(default_dir, "spotify_appkey.key") if not os.path.exists(app_key_path): print("\n" + Fore.YELLOW + "Please copy your spotify_appkey.key to " + default_dir + ", or use the --key|-k option" + Fore.RESET) sys.exit(1) config.load_application_key_file(app_key_path) # settings directory if args.settings is not None: settings_dir = norm_path(args.settings[0]) config.settings_location = settings_dir config.cache_location = settings_dir else: config.settings_location = default_dir config.cache_location = default_dir self.session = spotify.Session(config=config) self.session.volume_normalization = args.normalize bit_rates = dict([ ('160', BitRate.BITRATE_160K), ('320', BitRate.BITRATE_320K), ('96', BitRate.BITRATE_96K)]) self.session.preferred_bitrate(bit_rates[args.quality]) self.session.on(spotify.SessionEvent.CONNECTION_STATE_UPDATED, self.on_connection_state_changed) self.session.on(spotify.SessionEvent.END_OF_TRACK, self.on_end_of_track) self.session.on(spotify.SessionEvent.MUSIC_DELIVERY, self.on_music_delivery) self.session.on(spotify.SessionEvent.PLAY_TOKEN_LOST, self.play_token_lost) self.session.on(spotify.SessionEvent.LOGGED_IN, self.on_logged_in) self.event_loop = spotify.EventLoop(self.session) self.event_loop.start()
def _start_session(self): """Starts a Spotify session attribute.""" # TODO: should check if a session is already running # or end all other active sessions... hmmm. self._session = spotify.Session()
def __init__(self, user, password, key, sink, mixer='PCM', min_vol=0, max_vol=100): """ Initialises the Spotify Session, logs the user in and starts the session event loop. The player does not manage state, it simply cares about playing music. Arguments --------- user : str The Spotify User password : str The Spotify User Password key : str Path to the Spotify API Key File sink : str The audio sink to use mixer : str Mixer Name, default PCM min_vol : int Min volume level, default 0 max_vol : int Max volume level, default 100 """ # Mixer self.mixer = mixer # Volume Levels self.min_vol = int(min_vol) self.max_vol = int(max_vol) # Session Configuration logger.debug('Configuring Spotify Session') config = spotify.Config() config.load_application_key_file(key) config.dont_save_metadata_for_playlists = True config.initially_unload_playlists = True # Create session logger.debug('Creating Session') self.session = spotify.Session(config) self.register_session_events() self.session.preferred_bitrate(spotify.audio.Bitrate(1)) # Set the session event loop going logger.debug('Starting Spotify Event Loop') loop = spotify.EventLoop(self.session) loop.start() # Block until Login is complete logger.debug('Waiting for Login to Complete...') self.session.login(user, password, remember_me=True) LOGGED_IN_EVENT.wait() # Set the Audio Sink for the Session sinks = {'alsa': spotify.AlsaSink, 'fake': FakeSink} logger.info('Settingw Audio Sink to: {0}'.format(sink)) sinks.get(sink, FakeSink)(self.session)
import logging import json import spotify import codecs import os username = '******' #'tegjyotsingh' password = '******' #'werunited' logging.basicConfig(level=logging.DEBUG) config = spotify.Config() config.user_agent = 'Playlist Manager' session = spotify.Session(config=config) session.login(username, password, True) session.process_events() while session.connection.state != spotify.ConnectionState.LOGGED_IN: print session.connection.state session.process_events() print session.connection.state #p=session.search('e') #p.load() #p = session.playlist_container[0] p = session.get_starred() #p=session.get_playlist('spotify:user:anuteja:playlist:6ksaskR08sDR57kCtLI3W1') p.load() print p print p.tracks #playlist = session.playlist_container
def test(): print "Running tests..." import time session = spotify.Session() spotify.EventLoop(session).start() session.relogin() time.sleep(3) if os.path.exists("test_queue.txt"): os.remove("test_queue.txt") queue = MusicQueue("test_queue.txt") # Ensure we created a fresh queue. assert queue.get_queue_list() == [] print "Queue Creation Test Passed" # Test basic queue operations queue.insert("spotify:track:4hTt1HfFo0l5VuCOxhSFup") assert queue.get_queue_list() == ["spotify:track:4hTt1HfFo0l5VuCOxhSFup"] queue.insert("spotify:track:7HzCxalzzYQOFb9a7Xs3j6") assert queue.get_queue_list() == [ "spotify:track:4hTt1HfFo0l5VuCOxhSFup", "spotify:track:7HzCxalzzYQOFb9a7Xs3j6" ] queue.remove(1) assert queue.get_queue_list() == ["spotify:track:4hTt1HfFo0l5VuCOxhSFup"] queue.clear() assert queue.get_queue_list() == [] print "Basic Queue Operations Passed" # Test track selection/playlist management operations queue.set_fallback_playlist( "spotify:user:abartow123:playlist:0x0YazVnty6kO5U2l5OD5E") assert queue.get_next_track( session).link.uri == "spotify:track:3ezkJgagRPZ39KCTrKcSI7" queue.insert("spotify:track:4hTt1HfFo0l5VuCOxhSFup") assert queue.get_next_track( session).link.uri == "spotify:track:4hTt1HfFo0l5VuCOxhSFup" queue.current_track_complete() queue.clear_fallback_playlist() assert queue.get_queue_list() == [] print "Track selection tasks passed" # Test a handful of synchronous operations. def insertFromOtherThread(): other_queue = MusicQueue("test_queue.txt") other_queue.insert("spotify:track:7HzCxalzzYQOFb9a7Xs3j6") testComplete = threading.Event() def onTestFailure(): assert False testComplete.set() threading.Timer(0.25, insertFromOtherThread).start() failureWatchdog = threading.Timer(1, onTestFailure) failureWatchdog.start() def testNextTrack(): assert queue.get_next_track( session).link.uri == "spotify:track:7HzCxalzzYQOFb9a7Xs3j6" print "-- Testing get_next_track() Passed -- " failureWatchdog.cancel() testComplete.set() threading.Thread(None, testNextTrack).start() testComplete.wait() print "Synchronous Operations Passed" # Clean up. os.remove("test_queue.txt") print "All Tests Pass. :D"
def __init__(self, credentials): self.session = spotify.Session(credentials.spotify_client_id, credentials.spotify_client_secret, credentials.spotify_username)
def check_pyspotify_logged_in(self): logger.debug('Checking if pyspotify is logged in...') config = spotify.Config() config.user_agent = 'Spoppy' config.cache_location = os.path.join(self.user_cache_dir, 'cache') config.settings_location = os.path.join(self.user_cache_dir, 'cache') config.load_application_key_file( os.path.join(os.path.dirname(__file__), 'spotify_appkey.key')) self._pyspotify_session = spotify.Session(config) self._pyspotify_session_loop = spotify.EventLoop( self._pyspotify_session) self._pyspotify_session_loop.start() # Connect an audio sink self._sink_klass(self._pyspotify_session) # Events for coordination logged_in = threading.Event() # end_of_track = threading.Event() def on_connection_state_updated(session): KNOWN_STATES = ( 'DISCONNECTED', 'LOGGED_IN', 'LOGGED_OUT', 'OFFLINE', 'UNDEFINED', ) logger.debug('Checking connection state %s' % session.connection.state) for state in KNOWN_STATES: if (session.connection.state == getattr( spotify.ConnectionState, state)): logger.debug('Received connection state %s' % state) if session.connection.state == spotify.ConnectionState.LOGGED_IN: logged_in.set() disconnect_state = spotify.ConnectionState.DISCONNECTED if session.connection.state == disconnect_state: if self.player.is_playing(): self.player.play_pause(user_initiated=False) self.player.state = self.player.DISCONNECTED_INDICATOR logger.warning( 'Spoppy has been disconnected. DO YOU HAVE INTERNET?') else: if (self.player.state == self.player.DISCONNECTED_INDICATOR and not self.player.is_playing()): logger.debug('We got internet back, playing!') self.player.play_pause(user_initiated=False) self.player.state = None def on_lost_play_token(session): if self.player.is_playing(): self.player.play_pause() logger.warning( 'Spoppy has been paused. Spotify is probably playing ' 'somewhere else?') # Register event listeners self._pyspotify_session.on( spotify.SessionEvent.CONNECTION_STATE_UPDATED, on_connection_state_updated) self._pyspotify_session.on(spotify.SessionEvent.PLAY_TOKEN_LOST, on_lost_play_token) logger.debug('Actually logging in now...') self._pyspotify_session.login(self.username, self.password) logged_in.wait(5) if logged_in.is_set(): logger.debug('PySpotify logged in!') return True else: logger.warning('PySpotify login failed!') return False
def main(): #setup spotify config and initialize session config = spotify.Config() config.user_agent = 'spotify2playmusic' config.tracefile = b'/tmp/libspotify-trace.log' spot = spotify.Session(config=config) #log in and get playlist choice for cloning gpm = login_gpm() spot = login_spotify(spot) playlist = get_playlist(spot) #get google play playlist names and compare them to the chosen list #if there is a playlist with the same name already in google play then say so and exit gpm_playlist_names = [] for gpm_playlist in gpm.get_all_playlists(): gpm_playlist_names.append(gpm_playlist['name']) if playlist.load().name in gpm_playlist_names: print("Playlist already exists in Google Play... exiting") exit() #there will be two lists: one of tracks to be added and another #of songs that could not be matched tracks_to_match = [] to_add_list = [] unmatched_tracks = [] #searches user uploaded music first print("Searching in uploaded music first...") gpm_local = gpm.get_all_songs() print("Database loaded!") progress = 0 for track in playlist.load().tracks: progress += 1 track = track.load(timeout=30) title = track.name artist = track.artists[0].load().name album = track.album.load().name #for progress stdout.write("%i%% - %s - %s \r" % (((float(progress) / float(len(playlist.load().tracks))) * 100.0), title, artist)) stdout.flush() unmatched = True top5 = {} to_push_id = "" #checks against every song in the google play library and finds the #top 5 hits, then the one with the lowest levenshtein number is chosen for i in gpm_local: if is_similar(title, artist, album, i['title'], i['artist'], i['album']): print(" - Found a match in uploaded library: " + i['title'] + " - " + i['artist'] + " ") unmatched = False top5[i['title']] = i['id'] to_push_id = i['id'] if len(top5) == 5: break if len(top5) > 1: lowest_score = 999999 winning_track = "" for top in top5.keys(): val = levenshtein(title, top) if val < lowest_score: lowest_score = val to_push_id = top5[top] winning_track = top if winning_track is not "": print("Going with the closest match: " + winning_track) if unmatched: tracks_to_match.append(track) if to_push_id is not "": to_add_list.append(to_push_id) #all remaining unmatched tracks are searched in All Access print("Now searching All Access for the remaining tracks...") progress = 0 for track in tracks_to_match: progress +=1 track = track.load() title = track.name.lower() artist = track.artists[0].load().name.lower() album = track.album.load().name.lower() #only searches for title and artist because google play does not return #the correct results when album is included query = title + " " + artist #for progress stdout.flush() stdout.write("%i%% - %s - %s \r" % (((float(progress) / float(len(playlist.load().tracks))) * 100.0), title, artist)) unmatched = True #does two comparisons: one with the album and one where they both have #the same album, this will increase the chance of matching #I trust google's search function :) try: result = gpm.search_all_access(query, max_results = 10)['song_hits'][0]['track'] if is_similar(title, artist, album, result['title'].lower(), result['artist'].lower(), result['album']): print(" - Found a match in All Access: " + result['title'] + " - " + result['artist'] + " ") unmatched = False to_add_list.append(result['nid']) elif is_similar(title, artist, "analbumthebest", result['title'].lower(), result['artist'].lower(), "analbumthebest"): print(" - Found a match in All Access: " + result['title'] + " - " + result['artist'] + " ") unmatched = False to_add_list.append(result['nid']) else: unmatched_tracks.append(track) except Exception, e: print "Something went wrong while trying to search All Access...\n{}".format(str(e))
def create_real_session(lib_mock): """Create a real :class:`spotify.Session` using ``lib_mock``.""" lib_mock.sp_session_create.return_value = spotify.ErrorType.OK config = spotify.Config() config.application_key = b'\x01' * 321 return spotify.Session(config=config)
def getURI(searchTerm): try: search = session.search(searchTerm) print(search.load()) #(search.artist_total, search.album_total, search.track_total, track.playlist_total) print(search.artists[0].load().name) #get first result #eventually will go and get cover art at the same time #getCover(theAlbumURI) print(len(search.tracks)) #the total number of tracks print([a.load() for a in search.tracks ]) #if you leave "name" off, you get the uris trackNames = [a.load().name for a in search.tracks ] #make the list of all the track names trackURIs = [a.load() for a in search.tracks ] #make a list with all the track URIs return trackNames, trackURIs #lets play blackbird - which is 1 location except: print("sorry, I couldn't find ", searchTerm, " for you...") # Assuming a spotify_appkey.key in the current dir session = spotify.Session() # Process events in the background loop = spotify.EventLoop(session) loop.start() # Connect an audio sink - alsaSink is used on unix systems audio = spotify.AlsaSink(session) # Events for coordination logged_in = threading.Event() end_of_track = threading.Event() # Register event listeners session.on(spotify.SessionEvent.CONNECTION_STATE_UPDATED, on_connection_state_updated) session.on(spotify.SessionEvent.END_OF_TRACK, on_end_of_track) # Assuming a previous login, we may want to logout, especially if remember_me=True previously session.logout() #clear out any priors just in case session.forget_me() try: session.relogin() print("I re-logged you in good Sir...") except: session.login(username="******", password="******", remember_me=False) print("You have\'t been here in a bit...") #login and wait for the end of the track logged_in.wait() ##use this to print out what playlists you have #getPlaylist(trackURI) ##get the cover info - this one is still in progress #getCover(someTrackURIthatYouHave) #loop through the tracks for the Beatles and Play them all.... trackNames, trackURIs = getURI("The Beatles") #for every trackName and trackURI in the found lists for trackName, trackURI in zip(trackNames, trackURIs): #ask if we should play that song answer = str(input("Play " + trackName + " now?(Y,N)>")) #if yes, then stream it if answer != "N": print("Playing ", trackName, " ...") playTrack(trackURI) else: pass #make sure you log out session.logout() session.forget_me()