def __init__(self, serverHandler, username=None, password=None): self.serverHandler = serverHandler hdlr = logging.FileHandler(expanduser("~") + '/hapi.log') formatter = logging.Formatter('%(asctime)s %(levelname)s %(message)s') hdlr.setFormatter(formatter) self.logger.addHandler(hdlr) self.logger.setLevel(logging.INFO) self.logged_in = threading.Event() self.logged_out = threading.Event() self.logged_out.set() self.logger.info('Initializing player') self.session = spotify.Session() 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) try: self.audio_driver = spotify.AlsaSink(self.session) except ImportError: self.logger.warning( 'No audio sink found; audio playback unavailable.') self.event_loop = spotify.EventLoop(self.session) self.event_loop.start() if username is not None and password is not None: self.login(username, password) self.logger.info('Ready') self.currentTrack = None
def login(self): # Assuming a spotify_appkey.key in the current dir self.session = spotify.Session() # Process events in the background self._loop = spotify.EventLoop(self.session) self._loop.start() # Connect an audio sink if sys.platform == "darwin": audio = spotify.PortAudioSink(self.session) else: audio = spotify.AlsaSink(self.session) # Register event listeners self.session.on(spotify.SessionEvent.CONNECTION_STATE_UPDATED, self._on_connection_state_updated) self.session.on(spotify.SessionEvent.END_OF_TRACK, self._on_end_of_track) # Assuming a previous login with remember_me=True and a proper logout if self._settings.SPOTIFY_USERNAME == None or self._settings.SPOTIFY_PASSWORD == None: raise StandardError("No username/password") self.session.login(self._settings.SPOTIFY_USERNAME, self._settings.SPOTIFY_PASSWORD) self._logged_in.wait() return self.session
def __init__(self, controller): self._controller = controller self.current_track = None self.current_track_uri = None self.is_playing = False # spotify player instance variables self.logged_in_event = threading.Event() self.end_of_track_event = threading.Event() # spotify API config & login config = spotify.Config() keypath = sys.path[0]+"/spotify_appkey.key" config.load_application_key_file(filename=keypath) self.session = spotify.Session(config) self.session.login(SPOTIFY_AUTH['username'], SPOTIFY_AUTH['password']) # define audio sink spotify.AlsaSink(self.session, JUKEBIKE_CONF['PCM_ID']) # start event loop thread, which automatically processes events from lip event_loop = spotify.EventLoop(self.session) event_loop.start() # register listener for login, end of track / ... self.session.on(spotify.SessionEvent.LOGGED_IN, self.connection_state_listener) self.session.on(spotify.SessionEvent.END_OF_TRACK, self.track_state_listener) # is being called endlessly when track ends # TODO to be implemented, if necessary #CONNECTION_ERROR #MESSAGE_TO_USER # wait for login to succeed self.logged_in_event.wait()
def setUp(self): self.session = mock.Mock() self.session.num_listeners.return_value = 0 self.alsaaudio = mock.Mock() self.alsaaudio.pcms = mock.Mock() with mock.patch.dict('sys.modules', {'alsaaudio': self.alsaaudio}): self.sink = spotify.AlsaSink(self.session)
def __init__(self): self.playlist = None self.track = None # Track selected either by the user or the playlist to be played next self.curplaytrack = None # Currently playing track self.selindex = None # Index of self.track within self.playlist print('Start logging in') logged_in_event = threading.Event() def connection_state_listener(session, error_type): if error_type is spotify.ErrorType.OK: logged_in_event.set() else: print('Spotify authentication failed, please check login credentials') print('Program terminating') quit() self.session = spotify.Session(self.configsession()) self.audio = spotify.AlsaSink(self.session) loop = spotify.EventLoop(self.session) loop.start() self.session.on(spotify.SessionEvent.LOGGED_IN, connection_state_listener) from secrets import username from secrets import password self.session.login(username, password) # Blocks the thread until the log in operation completes logged_in_event.wait() print('Logged in as', username) # Set up listener for when the currently playing track finishes self.session.on(spotify.SessionEvent.END_OF_TRACK, self.next)
def account_login(self, source, username, passwd): if source == 'spotify': if self.session.connection.state is spotify.ConnectionState.LOGGED_IN: return # Process events in the background loop = spotify.EventLoop(self.session) loop.start() # Connect an audio sink try: audio = spotify.PortAudioSink(self.session) except: audio = spotify.AlsaSink(self.session) # Events for coordination self.logged_in = threading.Event() self.end_of_track = threading.Event() # Register event listeners self.session.on(spotify.SessionEvent.CONNECTION_STATE_UPDATED, self.on_connection_state_updated) self.session.on(spotify.SessionEvent.END_OF_TRACK, self.on_end_of_track) self.session.login(username, passwd) # Wait until flag is set true self.logged_in.wait() print self.session.user # self.session.inbox.load() logger.info("User %s successfully logged in.", self.session.user) self.logged_in.wait()
def __init__(self, session): self.session = session spotify.AlsaSink(session) self.end_of_track = threading.Event() self.current_song = -1 self.current_song_name = "" self.session.on(spotify.SessionEvent.END_OF_TRACK, self.on_end_of_track)
def __init__(self, session, ui): self.session = session self.ui = ui self.audio = spotify.AlsaSink(session) self.loop = spotify.EventLoop(session) self.loop.start() self.p_thread = player_thread.PlayerThread(self, self.session) self.p_thread.start()
def play(command): loop = spotify.EventLoop(session) loop.start() # Connect an audio sink audio = spotify.AlsaSink(session) # Events for coordination logged_in = threading.Event() end_of_track = threading.Event() def on_connection_state_updated(session): if session.connection.state is spotify.ConnectionState.LOGGED_IN: logged_in.set() def on_end_of_track(self): end_of_track.set() # 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 with remember_me=True and a proper logout session.relogin() logged_in.wait() commandl = command.split(" ") triggers = ['spotify', 'play'] triggerword = None for word in commandl: for trigger in triggers: if word.lower() == trigger: triggerword = word else: pass if triggerword == None: return "trigger word not found" else: searchterm = command.split(triggerword) search = session.search(searchterm) search = session.search(searchterm, search_type=spotify.SearchType.SUGGEST).load() playitem = None if len(search.tracks) > 0: playitem = search.tracks[0] track = session.get_track(track_uri).load() session.player.load(track) session.player.play() # Wait for playback to complete or Ctrl+C try: while not end_of_track.wait(0.1): pass except KeyboardInterrupt: pass
def __init__(self, config_file): with open(config_file, 'r') as fh: self.config = yaml.load(fh) self.session = spotify.Session() self.session.on(spotify.SessionEvent.CONNECTION_STATE_UPDATED, self.connection_state_listener) self.audio = spotify.AlsaSink(self.session) self.loop = spotify.EventLoop(self.session) self.logged_in = threading.Event()
def __init__ (self): self.session = spotify.Session() self.validLogin = False self.name = '' self.searchResults = False self.logged_in_event = threading.Event() #USeful fr login CHeck self.TopArtists = [] self.audio = spotify.AlsaSink(self.session) self.loop = spotify.EventLoop(self.session) self.loop.start() self.end_of_track = threading.Event()
def playtrack(tracks, username, password): logging.basicConfig(level=logging.DEBUG) config = spotify.Config() session = spotify.Session(config=config) #print session # Assuming a spotify_appkey.key in the current dir session.login(username, password, False) session.process_events() while session.connection.state != spotify.ConnectionState.LOGGED_IN: session.process_events() #print session.connection.state # Connect an audio sink audio = spotify.AlsaSink(session) # Events for coordination logged_in = threading.Event() end_of_track = threading.Event() def on_connection_state_updated(session): if session.connection.state is spotify.ConnectionState.LOGGED_IN: logged_in.set() def on_end_of_track(self): end_of_track.set() # 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) # Play a track #loop of tracks for i, track_uri in enumerate(tracks): if i < 4: #track_uri=random.choice(tracks) #print 'in for' track = session.get_track(track_uri).load() session.player.load(track) session.player.play() if i != 3: time.sleep(track.duration / 12000) #print 'hi' else: session.player.play(0) break audio.off()
def __init__(self, listener, controller): self.listener, self.controller = listener, controller self.session = spotify.Session() self.audio = spotify.AlsaSink(self.session) self.loop = spotify.EventLoop(self.session) self.logged_in = False self.playlist = None self.shuffledlist = None self.playlists = None self.track = None self.shuffle_mode = False self.playlist_length = 0 self.playlists_length = 0
def __init__(self): self.is_logged_in = False # We assume a spotify_appkey.key is in the current directory self.session = spotify.Session() # Process Spotify events automatically in the background loop = spotify.EventLoop(self.session) loop.start() # Connect to the AlsaAudio Sink, which works best for the Pi if you're on Linux, # but otherwise connect to the more versatile PortAudio sink if platform.system() == "Linux": audio = spotify.AlsaSink(self.session) else: audio = spotify.PortAudioSink(self.session)
def __init__(self): cmd.Cmd.__init__(self) self.logged_in = threading.Event() self.logged_out = threading.Event() self.logged_out.set() self.session = spotify.Session() 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) try: self.audio_driver = spotify.AlsaSink(self.session) except ImportError: self.logger.warning( 'No audio sink found; audio playback unavailable.') self.event_loop = spotify.EventLoop(self.session) self.event_loop.start()
def initialize(): global session global logged_in global playlist global length config = pyspotify.Config() config.user_agent = 'smart' # config.tracefile = b'/tmp/libspotify-trace.log' #if sys.argv[1:]: # track_uri = sys.argv[1] #else: # track_uri = 'spotify:track:6xZtSE6xaBxmRozKA0F6TA' # Assuming a spotify_appkey.key in the current dir session = pyspotify.Session(config) session.login('johnwbird', 'bitterjava60', True) # Process events in the background loop = pyspotify.EventLoop(session) loop.start() # Connect an audio sink audio = pyspotify.AlsaSink(session) # Register event listeners session.on(pyspotify.SessionEvent.CONNECTION_STATE_UPDATED, on_connection_state_updated) session.on(pyspotify.SessionEvent.END_OF_TRACK, on_end_of_track) # Assuming a previous login with remember_me=True and a proper logout #session.relogin() logged_in.wait() playlist = session.get_playlist( 'spotify:user:spotify:playlist:5FJXhjdILmRA2z5bvz4nzf') playlist.load().name length = len(playlist.tracks) random.seed() curSong = random.randint(0, length - 1)
def __init__(self, session, queue): audio = spotify.AlsaSink(session) self.queue = queue self.session = session # Login logged_in_event = threading.Event() def connection_state_listener(session): if session.connection.state is spotify.ConnectionState.LOGGED_IN: logged_in_event.set() self.session.on(spotify.SessionEvent.CONNECTION_STATE_UPDATED, connection_state_listener) self.session.login(settings.SPOTIFY_USER, settings.SPOTIFY_PASS) while not logged_in_event.wait(0.1): self.session.process_events() # waits until the login is complete loop = spotify.EventLoop(self.session) loop.start() self.session.on(spotify.SessionEvent.END_OF_TRACK, self.end_of_track)
def run_player(self): login = open( 'login.txt', 'r' ) #login.txt should be your login with username on the top line and password next credentials = login.read().split('\n') self.session = spotify.Session() audio = spotify.AlsaSink(self.session) loop = spotify.EventLoop(self.session) loop.start() self.session.on(spotify.SessionEvent.CONNECTION_STATE_UPDATED, self.is_loggedin) self.session.on(spotify.SessionEvent.END_OF_TRACK, self.is_song_end) self.session.login(credentials[0], credentials[1]) self.logged_in_event.wait() print 'waiting' print 'logged in' playlist = self.session.playlist_container[-1] playlist.load() self.queue = [track for track in playlist.tracks] random.shuffle(self.queue)
def __init__(self): self.end_of_track = threading.Event() self.logged_in = threading.Event() self.logged_out = threading.Event() self.logged_out.set() log.debug("Spawning spotify.Session()") self.session = spotify.Session() 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.tracks = [] myPlatform = platform.system() log.debug("Detecting platform") try: if myPlatform == 'Linux': log.info( "{0} platform detected; using ALSA".format(myPlatform)) self.audio_driver = spotify.AlsaSink(self.session) else: log.info("{0} platform detected; using PortAudio".format( myPlatform)) self.audio_driver = spotify.PortAudioSink(self.session) except ImportError as e: log.warning( 'No audio sink found; audio playback unavailable. Exception: {0}' .format(e.args)) # log.debug("spotify.Config()") # self.config = spotify.Config() # self.config.user_agent = 'Alarm Clock' log.debug("Spotify event loop") self.event_loop = spotify.EventLoop(self.session) self.event_loop.start()
def __init__(self, uname, pw, sink): self.userName = uname self.playlists = [] self.queue = deque() self.loggedIn = False self.status = "stopped" self.loggedInEvent = threading.Event() self.session = spotify.Session() if (sink == "alsa"): self.player = spotify.AlsaSink(self.session) elif (sink == "port"): self.player = spotify.PortAudioSink(self.session) else: print "unrecognized sink option: " + sink print "playback unavailable" self.loop = spotify.EventLoop(self.session) self.loop.start() self.session.on( spotify.SessionEvent.CONNECTION_STATE_UPDATED, self.connectionListener ) self.session.on( spotify.SessionEvent.END_OF_TRACK, self.playNextTrack ) self.session.login(uname, pw) while not self.loggedInEvent.wait(0.1): self.session.process_events() self.loggedIn = True
import spotify if sys.argv[1:]: track_uri = sys.argv[1] else: track_uri = 'spotify:track:6xZtSE6xaBxmRozKA0F6TA' # 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 audio = spotify.AlsaSink(session) # Events for coordination logged_in = threading.Event() end_of_track = threading.Event() def on_connection_state_updated(session): if session.connection.state is spotify.ConnectionState.LOGGED_IN: logged_in.set() def on_end_of_track(self): end_of_track.set()
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 spotify.AlsaSink(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() 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() 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 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()