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()
