def on_play_artist(self, intent, session, pid=None):
server = self._server
try:
artist = intent['slots']['Artist']['value']
print_d("Extracted artist slot: {}".format(artist))
except KeyError:
print_d("Couldn't process artist from: {intent}", intent=intent)
return speech_response(text=_("Couldn't process that artist. "))
else:
matched_artists = server.search_for_artist(artist)
print_d(
"Found Matching artists on squeezebox server "
"{matched_artists}",
matched_artists=matched_artists)
try:
server.play_artist(matched_artists[0], player_id=pid)
artist_name = sanitise_text(matched_artists[0])
text = _(
"Playing albums by \"{artist_name}\" on squeezebox".format(
artist_name=artist_name))
return self.smart_response(text=text, speech=text)
except KeyError:
return speech_response(
text=_("Couldn't find the artist on squeezebox. "))
raise ValueError("Don't understand intent '{}'".format(intent))
def on_play_playlist(self, intent, session, pid=None):
server = self._server
try:
slot = intent['slots']['Playlist']['value']
print_d("Extracted playlist slot: {slot}", slot=slot)
except KeyError:
print_d("Couldn't process playlist from: {intent}", intent=intent)
if not server.playlists:
return speech_response(text=_("There are no playlists"))
pl = random.choice(server.playlists)
text = _("Didn't hear a playlist there. "
"You could try the \"{name}\" playlist?").format(name=pl)
return speech_response(text=text)
else:
if not server.playlists:
return speech_response(text=_("No Squeezebox playlists found"))
result = process.extractOne(slot, server.playlists)
print_d("{guess} was the best guess for '{slot}' from {choices}",
guess=str(result),
slot=slot,
choices=server.playlists)
if result and int(result[1]) >= MinConfidences.PLAYLIST:
pl = result[0]
server.playlist_resume(pl, player_id=pid)
name = sanitise_text(pl)
return self.smart_response(
speech=_("Playing \"{name}\" playlist").format(name=name),
text=_("Playing \"{name}\" playlist").format(name=name))
pl = random.choice(server.playlists)
template = _("Couldn't find a playlist matching \"{name}\"."
"How about the \"{suggestion}\" playlist?")
return speech_response(template.format(name=slot, suggestion=pl))
def on_select_player(self, intent, session, pid=None):
srv = self._server
srv.refresh_status()
# Do it again, yes, but not defaulting this time.
pid = self.player_id_from(intent, defaulting=False)
if pid:
player = srv.players[pid]
srv.cur_player_id = player.id
text = _("Selected {player}").format(player=player.name)
title = _("Selected player {player}").format(player=player)
return speech_response(title=title,
text=text,
store={"player_id": pid})
speech = (_("I only found these players: {players}. "
"Could you try again?").format(
players=english_join(srv.player_names)))
reprompt = (_("You can select a player by saying \"{utterance}\" "
"and then the player name.").format(
utterance=Utterances.SELECT_PLAYER))
try:
player = intent['slots']['Player']['value']
title = (_("No player called \"{name}\"").format(name=player))
except KeyError:
title = "Didn't recognise a player name"
return speech_response(title,
speech,
reprompt_text=reprompt,
end=False)
def on_launch(self, launch_request, session):
print_d("Entering interactive mode for sessionId={}",
session['sessionId'])
speech_output = _("Squeezebox is online. Please try some commands.")
reprompt_text = _("Try resume, pause, next, previous, play some jazz, "
"or ask Squeezebox to turn it up or down")
return speech_response("Welcome", speech_output, reprompt_text,
end=False)
def lambda_handler(event, context):
""" Route the incoming request based on type (LaunchRequest, IntentRequest,
etc.) The JSON body of the request is provided in the event parameter.
"""
sqa = SqueezeAlexa(app_id=APPLICATION_ID)
try:
return sqa.handle(event, context)
except Exception as e:
if not settings.USE_SPOKEN_ERRORS:
raise e
# Work with AWS stack-trace log magic
print_w(format_exc().replace('\n', '\r'))
error = str(e.msg if hasattr(e, "msg") else e)
return speech_response(title=_("All went wrong"),
text=_("Oh dear: {type}. {message}").format(
type=type(e).__name__, message=error))
def lambda_handler(event, context, server=None):
""" Route the incoming request based on type (LaunchRequest, IntentRequest,
etc.) The JSON body of the request is provided in the event parameter.
"""
try:
sqa = SqueezeAlexa(server=server or get_server(),
app_id=SKILL_SETTINGS.application_id)
return sqa.handle(event, context)
except Exception as e:
if not SKILL_SETTINGS.use_spoken_errors:
raise e
# Work with AWS stack-trace log magic
print(format_exc().replace('\n', '\r'))
error = str(e.msg if hasattr(e, "msg") else e)
text = _("Oh dear: {type}. {message}").format(
type=type(e).__name__, message=error)
return speech_response(title=_("All went wrong"), text=text)
def smart_response(self,
speech=None,
title=None,
text=None,
reprompt_text=None,
end=True,
store=None):
if (self.audio_enabled) and (speech):
return speech_response(speech=speech,
title=title,
text=text,
reprompt_text=reprompt_text,
end=end,
store=store)
return audio_response(speech=speech,
title=title,
text=text,
reprompt_text=reprompt_text,
end=end,
store=store)
def smart_response(self, title=None, text=None, speech=None):
if self.audio_enabled:
return speech_response(title=title or text, text=speech)
return audio_response(speech=speech, text=text, title=title)
def on_session_ended(self, intent, session):
print_d("Session {id} ended", id=session['sessionId'])
speech_output = _("Hasta la vista. Baby.")
return speech_response("Session Ended", speech_output, end=True)
