Alexa Service Clients

def get_device_address_service(self): # type: () -> ask_sdk_model.services.device_address.DeviceAddressServiceClient def get_directive_service(self): # type: () -> ask_sdk_model.services.directive.DirectiveServiceClient def get_endpoint_enumeration_service(self): # type: () -> EndpointEnumerationServiceClient  def get_monetization_service(self): # type: () -> ask_sdk_model.services.monetization.MonetizationServiceClient def get_ups_service(self): # type: () -> ask_sdk_model.services.ups.UpsServiceClient def get_reminder_management_service(self): # type: () -> ask_sdk_model.services.reminder_management.ReminderManagementServiceClient 

class ask_sdk_model.services.api_client.ApiClient: def invoke(self, request): # type: (ApiClientRequest) -> ApiClientResponse class ask_sdk_model.services.api_client_request.ApiClientRequest(ApiClientMessage): def __init__(self, headers=None, body=None, url=None, method=None): # type: (List[Tuple[str, str]], str, str, str) -> None class ask_sdk_model.services.api_client_request.ApiClientResponse(ApiClientMessage): def __init__(self, headers=None, body=None, status_code=None): # type: (List[Tuple[str, str]], str, int) -> None class ask_sdk_model.services.api_client_message.ApiClientMessage(object): def __init__(self, headers=None, body=None): # type: (List[Tuple[str, str]], str) -> None 

from ask_sdk_core.skill_builder import CustomSkillBuilder sb = CustomSkillBuilder(api_client=<YourClassInstance>) 

from ask_sdk_core.skill_builder import CustomSkillBuilder from ask_sdk_core.api_client import DefaultApiClient sb = CustomSkillBuilder(api_client=DefaultApiClient()) 

class ask_sdk_model.services.device_address.DeviceAddressServiceClient: def get_country_and_postal_code(device_id): # type: (str) -> Union[ShortAddress, Error] def get_full_address(self, device_id): # type: (str) -> Union[Address, Error] class ask_sdk_model.services.device_address.ShortAddress: def __init__(self, country_code=None, postal_code=None): # type: (Optional[str], Optional[str]) -> None class ask_sdk_model.services.device_address.Address: def __init__( self, address_line1=None, address_line2=None, address_line3=None, country_code=None, state_or_region=None, city=None, district_or_county=None, postal_code=None): # type: (Optional[str], Optional[str], Optional[str], Optional[str], Optional[str], Optional[str], Optional[str], Optional[str]) -> None 

from ask_sdk_core.dispatch_components import AbstractRequestHandler from ask_sdk_core.handler_input import HandlerInput from ask_sdk_core.utils import is_intent_name from ask_sdk_model.response import Response from ask_sdk_model.ui import AskForPermissionsConsentCard from ask_sdk_model.services import ServiceException NOTIFY_MISSING_PERMISSIONS = ("Please enable Location permissions in " "the Amazon Alexa app.") NO_ADDRESS = ("It looks like you don't have an address set. " "You can set your address from the companion app.") ADDRESS_AVAILABLE = "Here is your full address: {}, {}, {}" ERROR = "Uh Oh. Looks like something went wrong." LOCATION_FAILURE = ("There was an error with the Device Address API. " "Please try again.") permissions = ["read::alexa:device:all:address"] class GetAddressIntentHandler(AbstractRequestHandler): def can_handle(self, handler_input): # type: (HandlerInput) -> bool return is_intent_name("GetAddressIntent")(handler_input) def handle(self, handler_input): # type: (HandlerInput) -> Response req_envelope = handler_input.request_envelope service_client_fact = handler_input.service_client_factory response_builder = handler_input.response_builder if not (req_envelope.context.system.user.permissions and req_envelope.context.system.user.permissions.consent_token): response_builder.speak(NOTIFY_MISSING_PERMISSIONS) response_builder.set_card( AskForPermissionsConsentCard(permissions=permissions)) return response_builder.response try: device_id = req_envelope.context.system.device.device_id device_addr_client = service_client_fact.get_device_address_service() addr = device_addr_client.get_full_address(device_id) if addr.address_line1 is None and addr.state_or_region is None: response_builder.speak(NO_ADDRESS) else: response_builder.speak(ADDRESS_AVAILABLE.format( addr.address_line1, addr.state_or_region, addr.postal_code)) return response_builder.response except ServiceException: response_builder.speak(ERROR) return response_builder.response except Exception as e: raise e 

class ask_sdk_model.services.directive.DirectiveServiceClient: def enqueue(self, send_directive_request): # type: (SendDirectiveRequest) -> Union[Error] class ask_sdk_model.services.directive.SendDirectiveRequest: def __init__(self, header=None, directive=None): # type: (Optional[Header], Optional[SpeakDirective]) -> None class ask_sdk_model.services.directive.SpeakDirective: def __init__(self, speech=None): # type: (Optional[str]) -> None 

from ask_sdk_core.handler_input import HandlerInput from ask_sdk_model.services.directive import ( SendDirectiveRequest, Header, SpeakDirective) import time def get_progressive_response(handler_input): # type: (HandlerInput) -> None request_id_holder = handler_input.request_envelope.request.request_id directive_header = Header(request_id=request_id_holder) speech = SpeakDirective(speech="Ok, give me a minute") directive_request = SendDirectiveRequest( header=directive_header, directive=speech) directive_service_client = handler_input.service_client_factory.get_directive_service() directive_service_client.enqueue(directive_request) time.sleep(5) return 

def init(self, api_configuration): # type: (ApiConfiguration) → None def get_endpoints(self, kwargs): # type: (Any) -> Union[EndpointEnumerationResponse, Error] 

from ask_sdk_core.skill_builder import CustomSkillBuilder from ask_sdk_core.api_client import DefaultApiClient .... skill_builder = CustomSkillBuilder(api_client=DefaultApiClient()) .... def get_connected_endpoints(handler_input: HandlerInput): return handler_input.service_client_factory.get_endpoint_enumeration_service().get_endpoints().endpoints 

class ask_sdk_model.services.monetization.MonetizationServiceClient: def get_in_skill_products( self, accept_language, purchasable=None, entitled=None, product_type=None, next_token=None, max_results=None): # type: (str, Optional[PurchasableState], Optional[EntitledState], Optional[ProductType], Optional[str], Optional[float]) -> Union[Error, InSkillProductsResponse] def get_in_skill_product(self, accept_language, product_id): # type: (str, str) -> Union[Error, InSkillProduct] def get_in_skill_products_transactions( self, accept_language, product_id=None, status=None, from_last_modified_time=None, to_last_modified_time=None, next_token=None, max_results=None): # type: (str, Optional[str], Optional[Status], Optional[datetime], Optional[datetime], Optional[str], Optional[float]) -> Union[Error, InSkillProductTransactionsResponse] def get_voice_purchase_setting(self): # type: () -> Union[Error, bool]  class ask_sdk_model.services.monetization.InSkillProductsResponse: def __init__(self, in_skill_products=None, is_truncated=None, next_token=None): # type: (Optional[List[InSkillProduct]], Optional[bool], Optional[str]) -> None class ask_sdk_model.services.monetization.InSkillProduct: self, product_id=None, reference_name=None, name=None, object_type=None, summary=None, purchasable=None, entitled=None, active_entitlement_count=None, purchase_mode=None def __init__( self, product_id=None, reference_name=None, name=None, object_type=None, summary=None, purchasable=None, entitled=None, active_entitlement_count=None, purchase_mode=None): # type: (Optional[str], Optional[str], Optional[str], Optional[ProductType], Optional[str], Optional[PurchasableState], Optional[EntitledState], Optional[int], Optional[PurchaseMode]) -> None class ask_sdk_model.services.monetization.ProductType(Enum): SUBSCRIPTION = "SUBSCRIPTION" ENTITLEMENT = "ENTITLEMENT" CONSUMABLE = "CONSUMABLE" class ask_sdk_model.services.monetization.PurchasableState(Enum): PURCHASABLE = "PURCHASABLE" NOT_PURCHASABLE = "NOT_PURCHASABLE" class ask_sdk_model.services.monetization.EntitledState(Enum): ENTITLED = "ENTITLED" NOT_ENTITLED = "NOT_ENTITLED" class ask_sdk_model.services.monetization.PurchaseMode(Enum): TEST = "TEST" LIVE = "LIVE" 

from ask_sdk_core.dispatch_components import AbstractRequestHandler from ask_sdk_core.handler_input import HandlerInput from ask_sdk_core.utils import is_request_type from ask_sdk_model.response import Response from ask_sdk_model.services.monetization import ( EntitledState, PurchasableState, InSkillProductsResponse) class LaunchRequestHandler(AbstractRequestHandler): def can_handle(self, handler_input): return is_request_type("LaunchRequest")(handler_input) def handle(self, handler_input): locale = handler_input.request_envelope.request.locale ms = handler_input.service_client_factory.get_monetization_service() product_response = ms.get_in_skill_products(locale) if isinstance(product_response, InSkillProductsResponse): total_products = len(product_response.in_skill_products) entitled_products = len([l for l in product_response.in_skill_products if l.entitled == EntitledState.ENTITLED]) purchasable_products = len([l for l in product_response.in_skill_products if l.purchasable == PurchasableState.PURCHASABLE]) speech = ( "Found total {} products of which {} are purchasable and {} " "are entitled".format( total_products, purchasable_products, entitled_products)) else: speech = "Something went wrong in loading your purchase history." return handler_input.response_builder.speak(speech).response 

from ask_sdk_core.dispatch_components import AbstractRequestHandler from ask_sdk_core.handler_input import HandlerInput from ask_sdk_core.utils import is_request_type from ask_sdk_model.response import Response from ask_sdk_model.services.monetization import InSkillProduct class LaunchRequestHandler(AbstractRequestHandler): def can_handle(self, handler_input): return is_request_type("LaunchRequest")(handler_input) def handle(self, handler_input): locale = handler_input.request_envelope.request.locale ms = handler_input.service_client_factory.get_monetization_service() product_id = "amzn1.adg.product.<GUID>" product_response = ms.get_in_skill_product(locale) if isinstance(product_response, InSkillProduct): # code to handle InSkillProduct goes here speech = "" pass else: speech = "Something went wrong in loading your product." return handler_input.response_builder.speak(speech).response 

 from ask_sdk_core.dispatch_components import AbstractRequestHandler from ask_sdk_core.handler_input import HandlerInput from ask_sdk_core.utils import is_request_type from ask_sdk_model.response import Response from ask_sdk_model.services.monetization import (Status, InSkillProductTransactionsResponse) class LaunchRequestHandler(AbstractRequestHandler): def can_handle(self, handler_input): return is_request_type("LaunchRequest")(handler_input) def handle(self, handler_input): locale = handler_input.request_envelope.request.locale ms = handler_input.service_client_factory.get_monetization_service() transaction_response = ms.get_in_skill_products_transactions(locale) if isinstance(transaction_response, InSkillProductTransactionsResponse): total_transaction = len(transaction_response.results) pending_transactions = len([l for l in transaction_response.results if l.status == Status.PENDING_APPROVAL_BY_PARENT]) approved_transactions = len([l for l in transaction_response.results if l.status == Status.APPROVED_BY_PARENT]) denied_transactions = len([l for l in transaction_response.results if l.status == Status.DENIED_BY_PARENT]) speech = ( "Found total {} transaction of which {} are pending, {} " "are approved and {} are denied".format( total_transaction, pending_transactions, approved_transactions, denied_transactions)) else: speech = "Something went wrong in loading your transaction history." return handler_input.response_builder.speak(speech).response 

 from ask_sdk_core.dispatch_components import AbstractRequestHandler from ask_sdk_core.handler_input import HandlerInput from ask_sdk_core.utils import is_request_type from ask_sdk_model.response import Response class LaunchRequestHandler(AbstractRequestHandler): def can_handle(self, handler_input): return is_request_type("LaunchRequest")(handler_input) def handle(self, handler_input): ms = handler_input.service_client_factory.get_monetization_service() purchase_preference_response = ms.get_voice_purchase_setting() if isinstance(purchase_preference_response, bool): speech = "Customer's purchase preference value is {}".format(purchase_preference_response) else: speech = "Something went wrong in loading customer's purchase preference settings." return handler_input.response_builder.speak(speech).response 

from ask_sdk_model.interfaces.connections import SendRequestDirective # In the skill flow, once a decision is made to offer an in-skill product to a # customer without an explicit ask from the customer return handler_input.response_builder.add_directive( SendRequestDirective( name="Upsell", payload={ "InSkillProduct": { "productId": "<product_id>", }, "upsellMessage": "<introductory upsell description for the in-skill product>", }, token="correlationToken") ).response 

from ask_sdk_core.dispatch_components import AbstractRequestHandler from ask_sdk_core.handler_input import HandlerInput from ask_sdk_core.utils import is_intent_name from ask_sdk_model.response import Response from ask_sdk_model.interfaces.connections import SendRequestDirective # Skills would implement a custom intent (BuyProductIntent below) that captures # user's intent to buy an in-skill product and then trigger the Buy request for it. # For e.g. 'Alexa, buy <product name>' class BuyProductIntentHandler(AbstractRequestHandler): def can_handle(self, handler_input): # type: (HandlerInput) -> bool return is_intent_name("BuyProductIntent")(handler_input) def handle(self, handler_input): # type: (HandlerInput) -> Response # Obtain the corresponding product_id for the requested in-skill # product by invoking InSkillProducts API. # The slot variable product_name used below is only for demonstration. locale = handler_input.request_envelope.request.locale ms = handler_input.service_client_factory.get_monetization_service() product_response = ms.get_in_skill_products(locale) slots = handler_input.request_envelope.request.intent.slots product_ref_name = slots.get("product_name").value product_record = [l for l in product_response.in_skill_products if l.reference_name == product_ref_name] if product_record: return handler_input.response_builder.add_directive( SendRequestDirective( name="Buy", payload={ "InSkillProduct": { "productId": product_record[0].product_id } }, token="correlationToken") ).response else: return handler_input.response_builder.speak( "I am sorry. That product is not available for purchase" ).response 

from ask_sdk_core.dispatch_components import AbstractRequestHandler from ask_sdk_core.handler_input import HandlerInput from ask_sdk_core.utils import is_intent_name from ask_sdk_model.response import Response from ask_sdk_model.interfaces.connections import SendRequestDirective # Skills would implement a custom intent (CancelProductIntent below) that captures # user's intent to cancel an in-skill product and then trigger the Cancel request for it. # For e.g. 'Alexa, cancel <product name>' class CancelProductIntentHandler(AbstractRequestHandler): def can_handle(self, handler_input): # type: (HandlerInput) -> bool return is_intent_name("CancelProductIntent")(handler_input) def handle(self, handler_input): # type: (HandlerInput) -> Response # Obtain the corresponding product_id for the requested in-skill # product by invoking InSkillProducts API. # The slot variable product_name used below is only for demonstration. locale = handler_input.request_envelope.request.locale ms = handler_input.service_client_factory.get_monetization_service() product_response = ms.get_in_skill_products(locale) slots = handler_input.request_envelope.request.intent.slots product_ref_name = slots.get("product_name").value product_record = [l for l in product_response.in_skill_products if l.reference_name == product_ref_name] if product_record: return handler_input.response_builder.add_directive( SendRequestDirective( name="Cancel", payload={ "InSkillProduct": { "productId": product_record[0].product_id } }, token="correlationToken") ).response else: return handler_input.response_builder.speak( "I am sorry. I don't know that one").response 

class ask_sdk_model.services.ups.UpsServiceClient: def get_profile_email(self): # type: () -> Union[str, Error] def get_profile_given_name(self): # type: () -> Union[str, Error] def get_profile_mobile_number(self): # type: () -> Union[PhoneNumber, Error] def get_profile_name(self): # type: () -> Union[str, Error] def get_system_distance_units(self, device_id): # type: (str) -> Union[Error, DistanceUnits] def get_system_temperature_unit(self, device_id): # type: (str) -> Union[TemperatureUnit, Error] def get_system_time_zone(self, device_id): # type: (str) -> Union[str, Error] class ask_sdk_model.services.ups.PhoneNumber: def __init__(self, country_code=None, phone_number=None): # type: (Optional[str], Optional[str]) -> None class ask_sdk_model.services.DistanceUnits(Enum): METRIC = "METRIC" IMPERIAL = "IMPERIAL" class ask_sdk_model.services.TemparatureUnit(Enum): CELSIUS = "CELSIUS" FAHRENHEIT = "FAHRENHEIT" 

req_envelope = handler_input.request_envelope device_id = req_envelope.context.system.device.device_id user_preferences_client = handler_input.service_client_factory.get_ups_service() # Fetch Preferred Distance Units From Alexa Settings API preferred_distance_units = user_preferences_client.get_system_distance_units(device_id).value print (preferred_distance_units) # String of either "IMPERIAL" or "METRIC" # Fetch Preferred Temperature Units From Alexa Settings API preferred_temperature_units = user_preferences_client.get_system_temperature_unit(device_id).value print (preferred_temperature_units) # String of either "FAHRENHEIT" or "CELSIUS" # Fetch Device's Current Configured Time Zone From Alexa Settings API time_zone = user_preferences_client.get_system_time_zone(device_id) print (time_zone) # String representing a time zone for example "America/Los_Angeles" 

class ask_sdk_model.services.reminder_management.ReminderManagementServiceClient: def create_reminder(self, reminder_request): # type: (ReminderRequest) -> Union[ReminderResponse, Error] def update_reminder(self, alert_token, reminder_request): # type: (str, ReminderRequest) -> Union[ReminderResponse, Error] def delete_reminder(self, alert_token): # type: (str) -> Union[Error] def get_reminder(self, alert_token): # type: (str) -> Union[GetReminderResponse, Error] def get_reminders(self): # type: () -> Union[GetRemindersResponse, Error] 

import logging import typing from datetime import datetime from ask_sdk_core.skill_builder import CustomSkillBuilder from ask_sdk_model.ui import SimpleCard from ask_sdk_core.utils import is_intent_name from ask_sdk_core.api_client import DefaultApiClient from ask_sdk_model.services.reminder_management import ( ReminderRequest, Trigger, TriggerType, AlertInfo, PushNotification, PushNotificationStatus, ReminderResponse, SpokenInfo, SpokenText) from ask_sdk_model.services import ServiceException from ask_sdk_model.ui import AskForPermissionsConsentCard if typing.TYPE_CHECKING: from ask_sdk_core.handler_input import HandlerInput from ask_sdk_model import Response permissions = ["alexa::alerts:reminders:skill:readwrite"] NOTIFY_MISSING_PERMISSIONS = ("Please enable Reminders permissions in " "the Amazon Alexa app.") sb = CustomSkillBuilder(api_client=DefaultApiClient()) logger = logging.getLogger(__name__) logger.setLevel(logging.INFO) @sb.request_handler(can_handle_func=is_intent_name("CreateReminder")) def create_reminder_intent_handler(handler_input): # type: (HandlerInput) -> Response req_envelope = handler_input.request_envelope response_builder = handler_input.response_builder # Check if user gave permissions to create reminders. # If not, request to provide permissions to the skill. if not (req_envelope.context.system.user.permissions and req_envelope.context.system.user.permissions.consent_token): response_builder.speak(NOTIFY_MISSING_PERMISSIONS) response_builder.set_card( AskForPermissionsConsentCard(permissions=permissions)) return response_builder.response reminder_client = handler_input.service_client_factory.get_reminder_management_service() try: reminder_response = reminder_client.create_reminder( reminder_request=ReminderRequest( request_time=datetime.utcnow(), trigger=Trigger( object_type=TriggerType.SCHEDULED_RELATIVE, offset_in_seconds=60), alert_info=AlertInfo( spoken_info=SpokenInfo( content=[SpokenText(locale="en-US", text="Test reminder")])), push_notification=PushNotification( status=PushNotificationStatus.ENABLED))) # type: ReminderResponse speech_text = "Great! I've scheduled a reminder for you." logger.info("Created reminder : {}".format(reminder_response)) return handler_input.response_builder.speak(speech_text).set_card( SimpleCard( "Reminder created with id", reminder_response.alert_token)).response except ServiceException as e: logger.info("Exception encountered : {}".format(e.body)) speech_text = "Uh Oh. Looks like something went wrong." return handler_input.response_builder.speak(speech_text).set_card( SimpleCard( "Reminder not created",str(e.body))).response