def play_artist(artist_name):
# Fetch the artist
artist = api.get_artist(artist_name)
if artist is False:
return statement("Sorry, I couldn't find that artist")
#api.get_artist found somthing from store api search
if 'topTracks' in artist:
# Setup the queue
first_song_id = queue.reset(artist['topTracks'])
nameKey = 'name'
trackType = 'top'
else: #api.get_artist searched the uploaded library instead, artist is a list
shuffle(artist)
first_song_id = queue.reset(artist)
#make artist just the first value in the dictionary for the rest of this function
artist = artist[0]
nameKey = 'artist'
trackType = 'random library'
# Get a streaming URL for the top song
stream_url = api.get_stream_url(first_song_id)
thumbnail = api.get_thumbnail(artist)
speech_text = "Playing %s tracks by %s" % (trackType, artist[nameKey])
return audio(speech_text).play(stream_url) \
.standard_card(title=speech_text,
text='',
small_image_url=thumbnail,
large_image_url=thumbnail)
def play_album(album_name, artist_name):
app.logger.debug("Fetching album %s by %s" % (album_name, artist_name))
# Fetch the album
album = api.get_album(album_name, artist_name)
if album is False:
return statement("Sorry, I couldn't find that album")
#store dict
if type(album) is dict:
# Setup the queue
first_song_id = queue.reset(album['tracks'])
albumNameKey = 'name'
else: #library list
first_song_id = queue.reset(sorted(album, key=lambda record: record['trackNumber']))
#make artist just the first value in the dictionary for the rest of this function
album = album[0]
albumNameKey = 'album'
# Start streaming the first track
stream_url = api.get_stream_url(first_song_id)
thumbnail = api.get_thumbnail(album)
speech_text = "Playing album %s by %s" % \
(album[albumNameKey], album['albumArtist'])
return audio(speech_text).play(stream_url) \
.standard_card(title=speech_text,
text='',
small_image_url=thumbnail,
large_image_url=thumbnail)
def play_similar_song_radio():
if len(queue.song_ids) == 0:
return statement("Please play a song to start radio")
if api.is_indexing():
return statement("Please wait for your tracks to finish indexing")
# Fetch the song
song = queue.current_track()
artist = api.get_artist(song['artist'])
album = api.get_album(song['album'])
app.logger.debug("Fetching songs like %s by %s from %s" % (song['title'], artist['name'], album['name']))
if song is False:
return statement("Sorry, I couldn't find that song")
station_id = api.get_station("%s Radio" %
song['title'], track_id=song['storeId'], artist_id=artist['artistId'], album_id=album['albumId'])
tracks = api.get_station_tracks(station_id)
first_song_id = queue.reset(tracks)
stream_url = api.get_stream_url(first_song_id)
thumbnail = api.get_thumbnail(queue.current_track()['albumArtRef'][0]['url'])
speech_text = "Playing %s by %s" % (song['title'], song['artist'])
return audio(speech_text).play(stream_url) \
.standard_card(title=speech_text,
text='',
small_image_url=thumbnail,
large_image_url=thumbnail)
def play_song_radio(song_name, artist_name, album_name):
app.logger.debug("Fetching song %s by %s from %s" % (song_name, artist_name, album_name))
# Fetch the song
song = api.get_song(song_name, artist_name, album_name)
if artist_name is not None:
artist = api.get_artist(artist_name)
else:
artist = api.get_artist(song['artist'])
if album_name is not None:
album = api.get_album(album_name)
else:
album = api.get_album(song['album'])
if song is False:
return statement("Sorry, I couldn't find that song")
station_id = api.get_station("%s Radio" %
song['title'], track_id=song['storeId'], artist_id=artist['artistId'], album_id=album['albumId'])
tracks = api.get_station_tracks(station_id)
first_song_id = queue.reset(tracks)
stream_url = api.get_stream_url(first_song_id)
thumbnail = api.get_thumbnail(queue.current_track()['albumArtRef'][0]['url'])
speech_text = "Playing %s by %s" % (song['title'], song['artist'])
return audio(speech_text).play(stream_url) \
.standard_card(title=speech_text,
text='',
small_image_url=thumbnail,
large_image_url=thumbnail)
def play_artist_radio(artist_name):
# Fetch the artist
artist = api.get_artist(artist_name)
app.logger.debug("Fetching artist %s" % artist_name)
if artist is False:
return statement(render_template("no_artist"))
station_id = api.get_station("%s Radio" % artist['name'],
artist_id=artist['artistId'])
# TODO: Handle track duplicates (this may be possible using session ids)
tracks = api.get_station_tracks(station_id)
first_song_id = queue.reset(tracks)
# Get a streaming URL for the top song
stream_url = api.get_stream_url(first_song_id)
thumbnail = None
speech_text = render_template("play_artist_radio_text",
artist=artist['name'])
return audio(speech_text).play(stream_url) \
.standard_card(title=speech_text,
text='',
small_image_url=thumbnail,
large_image_url=thumbnail)
def play_playlist(playlist_name):
# Retreve the content of all playlists in a users library
all_playlists = api.get_all_user_playlist_contents()
# Give each playlist a score based on its similarity to the requested
# playlist name
request_name = playlist_name.lower().replace(" ", "")
scored_playlists = []
for i, playlist in enumerate(all_playlists):
name = playlist['name'].lower().replace(" ", "")
scored_playlists.append({
'index': i,
'name': name,
'score': fuzz.ratio(name, request_name)
})
sorted_playlists = sorted(scored_playlists,
lambda a, b: b['score'] - a['score'])
top_scoring = sorted_playlists[0]
best_match = all_playlists[top_scoring['index']]
# Make sure we have a decent match (the score is n where 0 <= n <= 100)
if top_scoring['score'] < 80:
return statement(
"Sorry, I couldn't find that playlist in your library.")
# Add songs from the playlist onto our queue
first_song_id = queue.reset(best_match['tracks'])
# Get a streaming URL for the first song in the playlist
stream_url = api.get_stream_url(first_song_id)
speech_text = "Playing songs from %s" % (best_match['name'])
return audio(speech_text).play(stream_url)
def play_artist_radio(artist_name):
# TODO -- can we do this without a subscription?
if not api.use_store:
return statement(render_template("not_supported_without_store"))
if not api.use_store and api.is_indexing():
return statement(render_template("indexing"))
# Fetch the artist
artist = api.get_artist(artist_name)
if artist is False:
return statement(render_template("no_artist"))
station_id = api.get_station("%s Radio" % artist['name'],
artist_id=artist['artistId'])
# TODO: Handle track duplicates (this may be possible using session ids)
tracks = api.get_station_tracks(station_id)
first_song_id = queue.reset(tracks)
# Get a streaming URL for the top song
stream_url = api.get_stream_url(first_song_id)
if "albumArtRef" in album:
thumbnail = api.get_thumbnail(album['albumArtRef'])
else:
thumbnail = None
speech_text = render_template("play_artist_radio_text",
artist=artist['name'])
return audio(speech_text).play(stream_url) \
.standard_card(title=speech_text,
text='',
small_image_url=thumbnail,
large_image_url=thumbnail)
def play_album(album_name, artist_name):
if not api.use_store and api.is_indexing():
return statement(render_template("indexing"))
app.logger.debug("Fetching album %s" % album_name)
# Fetch the album
album = api.get_album(album_name, artist_name)
if album is False:
return statement(render_template("no_album"))
# Setup the queue
first_song_id = queue.reset(album['tracks'])
# Start streaming the first track
stream_url = api.get_stream_url(first_song_id)
if "albumArtRef" in album:
thumbnail = api.get_thumbnail(album['albumArtRef'])
else:
thumbnail = None
speech_text = render_template("play_album_text",
album=album['name'],
artist=album['albumArtist'])
app.logger.debug(speech_text)
return audio(speech_text).play(stream_url) \
.standard_card(title=speech_text,
text='',
small_image_url=thumbnail,
large_image_url=thumbnail)
def play_different_album():
# TODO -- can we do this without a subscription?
if not api.use_store:
return statement(render_template("not_supported_without_store"))
api = GMusicWrapper.generate_api()
current_track = queue.current_track()
if current_track is None:
return statement(render_template("play_different_album_no_track"))
album = api.get_album_by_artist(artist_name=current_track['artist'],
album_id=current_track['albumId'])
if album is False:
return statement(render_template("no_album"))
# Setup the queue
first_song_id = queue.reset(album['tracks'])
# Start streaming the first track
stream_url = api.get_stream_url(first_song_id)
speech_text = render_template("play_album_text",
album=album['name'],
artist=album['albumArtist'])
return audio(speech_text).play(stream_url)
def play_album(album_name, artist_name):
app.logger.debug("Fetching album %s by %s" % (album_name, artist_name))
# Fetch the album
album = api.get_album(album_name, artist_name)
if album is False:
return statement("Sorry, I couldn't find that album")
# Setup the queue
first_song_id = queue.reset(album['tracks'])
# Start streaming the first track
stream_url = api.get_stream_url(first_song_id)
try:
thumbnail = api.get_thumbnail(album['albumArtRef'])
except:
thumbnail = ""
speech_text = "Playing album %s by %s" % \
(album['name'], album['albumArtist'])
if (thumbnail==""):
return audio(speech_text).play(stream_url) \
.standard_card(title=speech_text,
text='',
small_image_url=thumbnail,
large_image_url=thumbnail)
else:
return audio(speech_text).play(stream_url) \
.simple_card(title=speech_text, content='')
def play_song(song_name, artist_name):
if not api.use_store and api.is_indexing():
return statement(render_template("indexing"))
app.logger.debug("Fetching song %s by %s" % (song_name, artist_name))
# Fetch the song
song = api.get_song(song_name, artist_name)
if song is False:
return statement(render_template("no_song"))
# Start streaming the first track
first_song_id = queue.reset([song])
stream_url = api.get_stream_url(first_song_id)
if "albumArtRef" in queue.current_track():
thumbnail = api.get_thumbnail(
queue.current_track()['albumArtRef'][0]['url'])
else:
thumbnail = None
speech_text = render_template("play_song_text",
song=song['title'],
artist=song['artist'])
return audio(speech_text).play(stream_url) \
.standard_card(title=speech_text,
text='',
small_image_url=thumbnail,
large_image_url=thumbnail)
def play_song(song_name, artist_name):
app.logger.debug("Fetching song %s by %s" % (song_name, artist_name))
# Fetch the song
song = api.get_song(song_name, artist_name)
if song is False:
return statement("Sorry, I couldn't find that song")
# Start streaming the first track
first_song_id = queue.reset([song])
stream_url = api.get_stream_url(first_song_id)
try:
thumbnail = api.get_thumbnail(queue.current_track()['albumArtRef'][0]['url'])
except:
thumbnail = ""
speech_text = "Playing %s by %s" % (song['title'], song['artist'])
if (thumbnail==""):
return audio(speech_text).play(stream_url) \
.standard_card(title=speech_text,
text='',
small_image_url=thumbnail,
large_image_url=thumbnail)
else:
return audio(speech_text).play(stream_url) \
.simple_card(title=speech_text, content='')
def play_artist_radio(name):
if str(environ['USE_LIBRARY_FIRST']) is True:
# return statement("Sorry, artist radios aren't currently supported at the moment.")
return None
# Fetch the artist
artist = api.get_artist(name)
if artist is False:
return statement("Sorry, I couldn't find that artist")
# station_id = api.get_station("%s Radio" % artist['name'], artist_id=artist['artistId'])
station_id = api.get_station("%s Radio" % artist['name'],
artist_id=artist['artistId'])
#if str(environ['USE_LIBRARY_FIRST']) is True:
#_station_info = api.get_station_info(station_id, 999) # 999 is the maximium number of tracks to return. I will set it to a lower amount should this cause some lag...
# TODO: Handle track duplicates (this may be possible using session ids)
tracks = api.get_station_tracks(station_id)
first_song_id = queue.reset(tracks)
#if str(enviorn['USE_LIBRARY_FIRST']) is True:
# Get a radio station for free accounts
#stream_url = api.get_station_track_stream_url(first_song_id, _station_info.get('wentryid', None), _station_info.get('sessionToken', None))
#else:
# Get a streaming URL for the top song
stream_url = api.get_stream_url(first_song_id)
thumbnail = api.get_thumbnail(artist)
speech_text = "Playing %s radio" % artist['name']
return audio(speech_text).play(stream_url) \
.standard_card(title=speech_text,
text='',
small_image_url=thumbnail,
large_image_url=thumbnail)
def play_artist(artist_name):
# Fetch the artist
artist = api.get_artist(artist_name)
if artist is False:
return statement("Sorry, I couldn't find that artist")
# Setup the queue
first_song_id = queue.reset(artist['topTracks'])
# Get a streaming URL for the top song
stream_url = api.get_stream_url(first_song_id)
try:
thumbnail = api.get_thumbnail(artist['artistArtRef'])
except:
thumbnail = ""
speech_text = "Playing top tracks by %s" % artist['name']
if (thumbnail==""):
return audio(speech_text).play(stream_url) \
.standard_card(title=speech_text,
text='',
small_image_url=thumbnail,
large_image_url=thumbnail)
else:
return audio(speech_text).play(stream_url) \
.simple_card(title=speech_text, content='')
def play_playlist(playlist_name):
# Retreve the content of all playlists in a users library
all_playlists = api.get_all_user_playlist_contents()
# Get the closest match
best_match = api.closest_match(playlist_name, all_playlists)
if best_match is None:
return statement("Sorry, I couldn't find that playlist in your library.")
# Add songs from the playlist onto our queue
first_song_id = queue.reset(best_match['tracks'])
# Get a streaming URL for the first song in the playlist
stream_url = api.get_stream_url(first_song_id)
try:
thumbnail = api.get_thumbnail(queue.current_track()['albumArtRef'][0]['url'])
except:
thumbnail = ""
speech_text = "Playing songs from %s" % (best_match['name'])
if (thumbnail != ""):
return audio(speech_text).play(stream_url) \
.standard_card(title=speech_text,
text='',
small_image_url=thumbnail,
large_image_url=thumbnail)
else:
return audio(speech_text).play(stream_url) \
.simple_card(title=speech_text, content='')
def play_artist_radio(artist_name):
# Fetch the artist
artist = api.get_artist(artist_name)
if artist is False:
return statement("Sorry, I couldn't find that artist")
station_id = api.get_station("%s Radio" %
artist['name'], artist_id=artist['artistId'])
# TODO: Handle track duplicates (this may be possible using session ids)
tracks = api.get_station_tracks(station_id)
first_song_id = queue.reset(tracks)
# Get a streaming URL for the top song
stream_url = api.get_stream_url(first_song_id)
try:
thumbnail = api.get_thumbnail(artist['artistArtRef'])
except:
thumbnail = ""
speech_text = "Playing %s radio" % artist['name']
if (thumbnail==""):
return audio(speech_text).play(stream_url) \
.standard_card(title=speech_text,
text='',
small_image_url=thumbnail,
large_image_url=thumbnail)
else:
return audio(speech_text).play(stream_url) \
.simple_card(title=speech_text, content='')
def play_playlist(playlist_name):
if not api.use_store and api.is_indexing():
return statement(render_template("indexing"))
# Retreve the content of all playlists in a users library
all_playlists = api.get_all_user_playlist_contents()
# Get the closest match
best_match = api.closest_match(playlist_name, all_playlists)
if best_match is None:
return statement(render_template("play_playlist_no_match"))
# Add songs from the playlist onto our queue
first_song_id = queue.reset(best_match['tracks'])
# Get a streaming URL for the first song in the playlist
stream_url = api.get_stream_url(first_song_id)
if "albumArtRef" in queue.current_track():
thumbnail = api.get_thumbnail(
queue.current_track()['albumArtRef'][0]['url'])
else:
thumbnail = None
speech_text = render_template("play_playlist_text",
playlist=best_match['name'])
return audio(speech_text).play(stream_url) \
.standard_card(title=speech_text,
text='',
small_image_url=thumbnail,
large_image_url=thumbnail)
def play_artist(artist_name):
if not api.use_store and api.is_indexing():
return statement(render_template("indexing"))
# Fetch the artist
artist = api.get_artist(artist_name)
if artist is False:
return statement(
render_template("play_artist_none", artist=artist_name))
# Setup the queue
first_song_id = queue.reset(artist['topTracks'])
# Get a streaming URL for the top song
stream_url = api.get_stream_url(first_song_id)
if "artistArtRef" in artist:
thumbnail = api.get_thumbnail(artist['albumArtRef'])
else:
thumbnail = None
if api.use_store:
speech_text = render_template("play_artist_text",
artist=artist['name'])
else:
speech_text = render_template("play_artist_text_library",
artist=artist['name'])
return audio(speech_text).play(stream_url) \
.standard_card(title=speech_text,
text='',
small_image_url=thumbnail,
large_image_url=thumbnail)
def play_song(song_name, artist_name):
api = GMusicWrapper.generate_api()
queue.reset()
app.logger.debug("Fetching song %s by %s" % (song_name, artist_name))
# Fetch the song
song = api.get_song(song_name, artist_name=artist_name)
if song == False:
return statement("Sorry, I couldn't find that song")
# Start streaming the first track
stream_url = api.get_stream_url(song['storeId'])
speech_text = "Playing song %s by %s" % (song['title'], song['artist'])
return audio(speech_text).play(stream_url)
def play_artist_radio(artist_name):
# TODO: Handle track duplicates?
tracks = api.get_station_tracks("IFL")
# Get a streaming URL for the first song
first_song_id = queue.reset(tracks)
stream_url = api.get_stream_url(first_song_id)
speech_text = "Playing music from your personalized station"
return audio(speech_text).play(stream_url)
def play_library():
if api.is_indexing():
return statement("Please wait for your tracks to finish indexing")
tracks = api.library.values()
first_song_id = queue.reset(tracks)
first_song_id = queue.shuffle_mode(True)
stream_url = api.get_stream_url(first_song_id)
speech_text = "Playing music from your library"
return audio(speech_text).play(stream_url)
def play_library():
if api.is_indexing():
return statement(render_template("indexing"))
tracks = api.library.values()
first_song_id = queue.reset(tracks)
first_song_id = queue.shuffle_mode(True)
stream_url = api.get_stream_url(first_song_id)
speech_text = render_template("play_library_text")
return audio(speech_text).play(stream_url)
def play_IFL_radio(artist_name):
# TODO: Handle track duplicates?
tracks = api.get_station_tracks("IFL")
# Get a streaming URL for the first song
first_song_id = queue.reset(tracks)
stream_url = api.get_stream_url(first_song_id)
speech_text = "Playing music from your personalized station"
thumbnail = api.get_thumbnail("https://i.imgur.com/NYTSqHZ.png")
return audio(speech_text).play(stream_url) \
.standard_card(title="Playing I'm Feeling Lucky Radio",
text='',
small_image_url=thumbnail,
large_image_url=thumbnail)
def play_artist(artist_name):
# Fetch the artist
artist = api.get_artist(artist_name)
if artist == False:
return statement("Sorry, I couldn't find that artist")
# Setup the queue
first_song_id = queue.reset(artist['topTracks'])
# Get a streaming URL for the top song
stream_url = api.get_stream_url(first_song_id)
speech_text = "Playing top tracks from %s" % artist['name']
return audio(speech_text).play(stream_url)
def play_album_by_artist(artist_name):
api = GMusicWrapper.generate_api()
album = api.get_album_by_artist(artist_name=artist_name)
if album is False:
return statement("Sorry, I couldn't find any albums.")
# Setup the queue
first_song_id = queue.reset(album['tracks'])
# Start streaming the first track
stream_url = api.get_stream_url(first_song_id)
speech_text = "Playing album %s by %s" % (album['name'], album['albumArtist'])
return audio(speech_text).play(stream_url)
def play_song(song_name, artist_name):
app.logger.debug("Fetching song %s by %s" % (song_name, artist_name))
# Fetch the song
song = api.get_song(song_name, artist_name)
if song == False:
return statement("Sorry, I couldn't find that song")
# Start streaming the first track
first_song_id = queue.reset([song])
stream_url = api.get_stream_url(first_song_id)
speech_text = "Playing %s by %s" % (song['title'], song['artist'])
return audio(speech_text).play(stream_url)
def play_IFL_radio(artist_name):
# TODO: Handle track duplicates?
tracks = api.get_station_tracks("IFL")
# Get a streaming URL for the first song
first_song_id = queue.reset(tracks)
stream_url = api.get_stream_url(first_song_id)
speech_text = render_template("play_IFL_radio_text")
thumbnail = api.get_thumbnail("https://i.imgur.com/NYTSqHZ.png")
return audio(speech_text).play(stream_url) \
.standard_card(title=render_template("play_IFL_radio_title"),
text='',
small_image_url=thumbnail,
large_image_url=thumbnail)
def play_artist(artist_name):
# Fetch the artist
artist = api.get_artist(artist_name)
if artist is False:
return statement(render_template("play_artist_none"))
# Setup the queue
first_song_id = queue.reset(artist['topTracks'])
# Get a streaming URL for the top song
stream_url = api.get_stream_url(first_song_id)
#thumbnail = api.get_thumbnail(artist['artistArtRef'])
speech_text = render_template("play_artist_text", artist=artist['name'])
return audio(speech_text).play(stream_url) #\
def play_song_radio(song_name, artist_name, album_name):
if not api.use_store and api.is_indexing():
return statement(render_template("indexing"))
app.logger.debug("Fetching song %s by %s from %s." %
(song_name, artist_name, album_name))
# Fetch the song
song = api.get_song(song_name, artist_name, album_name)
if song is False:
return statement(render_template("no_song"))
if artist_name is not None:
artist = api.get_artist(artist_name)
else:
artist = api.get_artist(song['artist'])
if album_name is not None:
album = api.get_album(album_name)
else:
album = api.get_album(song['album'])
station_id = api.get_station("%s Radio" % song['title'],
track_id=song['storeId'],
artist_id=artist['artistId'],
album_id=album['albumId'])
tracks = api.get_station_tracks(station_id)
first_song_id = queue.reset(tracks)
stream_url = api.get_stream_url(first_song_id)
if "albumArtRef" in queue.current_track():
thumbnail = api.get_thumbnail(
queue.current_track()['albumArtRef'][0]['url'])
else:
thumbnail = None
speech_text = render_template("play_song_text",
song=song['title'],
artist=song['artist'])
return audio(speech_text).play(stream_url) \
.standard_card(title=speech_text,
text='',
small_image_url=thumbnail,
large_image_url=thumbnail)
def play_album_by_artist(artist_name):
api = GMusicWrapper.generate_api()
album = api.get_album_by_artist(artist_name=artist_name)
if album is False:
return statement(render_template("no_album"))
# Setup the queue
first_song_id = queue.reset(album['tracks'])
# Start streaming the first track
stream_url = api.get_stream_url(first_song_id)
speech_text = render_template("play_album_text",
album=album['name'],
artist=album['albumArtist'])
return audio(speech_text).play(stream_url)
