def __init__(self): self.config = Config() self.luis_app = LuisApplication( self.config.luis_app_id, self.config.luis_endpoint_key, self.config.luis_endpoint, ) self.luis_option = LuisPredictionOptions( include_all_intents=True, include_instance_data=True, ) self.Luis_recognizer = LuisRecognizer( application=self.luis_app, prediction_options=self.luis_option, include_api_results=True)
async def excecute_luis_query(configuration: dict, turn_context: TurnContext) -> JobSearch: job_search = JobSearch() #try: luis_application = LuisApplication(configuration['LUIS_APP_ID'], configuration['LUIS_API_KEY'], configuration['LUIS_API_HOST_NAME']) recognizer = LuisRecognizer(luis_application) recognizer_result = await recognizer.recognize(turn_context) print("recognizer") print(recognizer_result) if recognizer_result.intents: intent = sorted(recognizer_result.intents, key=recognizer_result.intents.get, reverse=True)[:1][0] if intent == 'FindJob': # We need to get the result from the LUIS JSON which at every level returns an array. jobtype_entity = recognizer_result.entities.get( "$instance", {}).get("jobtype", []) if len(jobtype_entity) > 0: job_search.jobtype = jobtype_entity[0]['text'] location_entities = recognizer_result.entities.get( "$instance", {}).get("location", []) if len(location_entities) > 0: job_search.location = location_entities[0]['text'] # except Exception as e: # print("ERROR") # print(e) return job_search
async def execute_luis_query(configuration: dict, turn_context: TurnContext) -> BookingDetails: """Invoke LUIS service to perform prediction/evaluation of utterance.""" booking_details = BookingDetails() # pylint:disable=broad-except try: luis_application = LuisApplication( configuration['LUIS_APP_ID'], configuration['LUIS_API_KEY'], configuration['LUIS_API_HOST_NAME'] ) recognizer = LuisRecognizer(luis_application) recognizer_result = await recognizer.recognize(turn_context) if recognizer_result.intents: intent = sorted(recognizer_result.intents, key=recognizer_result.intents.get, reverse=True)[:1][0] if intent == 'Book_flight': # We need to get the result from the LUIS JSON which at every level returns an array. to_entities = recognizer_result.entities.get("$instance", {}).get("To", []) if to_entities: booking_details.destination = to_entities[0]['text'] from_entities = recognizer_result.entities.get("$instance", {}).get("From", []) if from_entities: booking_details.origin = from_entities[0]['text'] # This value will be a TIMEX. And we are only interested in a Date so grab the first result and drop the Time part. # TIMEX is a format that represents DateTime expressions that include some ambiguity. e.g. missing a Year. date_entities = recognizer_result.entities.get("$instance", {}).get("datetime", []) if date_entities: booking_details.travel_date = None # Set when we get a timex format except Exception as exception: print(exception) return booking_details
def _get_luis_recognizer( cls, verbose: bool = False, options: LuisPredictionOptions = None ) -> LuisRecognizer: luis_app = LuisApplication(cls._luisAppId, cls._subscriptionKey, cls._endpoint) return LuisRecognizer( luis_app, prediction_options=options, include_api_results=verbose )
async def on_message_activity(self,turn_context:TurnContext): conmode = await self.conprop.get(turn_context,ConState) ordermode = await self.userprop.get(turn_context,Order) luis_result = await self.LuisReg.recognize(turn_context) intent = LuisRecognizer.top_intent(luis_result) await turn_context.send_activity(f"Top Intent : {intent}") retult = luis_result.properties["luisResult"] item = '' if len(retult.entities) != 0: await turn_context.send_activity(f" Luis Result {retult.entities[0]}") item = retult.entities[0].entity if(conmode.orderstatus == EnumOrder.ENTREE): await turn_context.send_activity("Please enter a main Entree") conmode.orderstatus = EnumOrder.SIDE elif(conmode.orderstatus == EnumOrder.SIDE): ordermode.entree = item await turn_context.send_activity("Please enter a side dish") conmode.orderstatus = EnumOrder.DRINK elif(conmode.orderstatus == EnumOrder.DRINK): await turn_context.send_activity("Please a drink") ordermode.side = item conmode.orderstatus = EnumOrder.DONE elif(conmode.orderstatus == EnumOrder.DONE): ordermode.drink = item info = ordermode.entree + " " + ordermode.side + " " + ordermode.drink await turn_context.send_activity(info) conmode.orderstatus = EnumOrder.ENTREE
class LuisBot(ActivityHandler): def __init__(self): self.config = Config() self.luis_app = LuisApplication( self.config.luis_app_id, self.config.luis_endpoint_key, self.config.luis_endpoint, ) self.luis_option = LuisPredictionOptions( include_all_intents=True, include_instance_data=True, ) self.Luis_recognizer = LuisRecognizer( application=self.luis_app, prediction_options=self.luis_option, include_api_results=True) async def on_message_activity(self, turn_context: TurnContext): weather = Weather() luis_result = await self.Luis_recognizer.recognize(turn_context) # intent = LuisRecognizer.top_intent(luis_result) intent = self.Luis_recognizer.top_intent(luis_result) result = luis_result.properties["luisResult"] json_str = json.loads((str(result.entities[0])).replace("'", "\"")) entity = json_str.get("entity") weather_info = weather.get_weather_info(entity) # await turn_context.send_activity(f"Entity {result.entities[0]}") await turn_context.send_activity(f"Top Intent : {intent}") await turn_context.send_activity(f"Entity {entity}") await turn_context.send_activity(f"{weather_info}")
async def on_message_activity(self, turn_context:TurnContext): luis_result = await self.LuisReg.recognize(turn_context) #extract top intent intent = LuisRecognizer.top_intent(luis_result) await turn_context.send_activity(f"Top Intent: {intent}") result = luis_result.properties["luisResult"] await turn_context.send_activity(f"Luis Result: {result.entities[0]}")
async def excecute_luis_query(configuration: dict, turn_context: TurnContext) -> BookingDetails: booking_details = BookingDetails() try: luis_application = LuisApplication( configuration['LuisApplication'], configuration['LuisAPIKey'], 'https://' + configuration['LuisAPIHostName']) recognizer = LuisRecognizer(luis_application) recognizer_result = await recognizer.recognize(turn_context) intent = sorted( recognizer_result.intents, key=recognizer_result.intents.get, reverse=True)[:1] if recognizer_result.intents else None if intent == 'Book_flight': # We need to get the result from the LUIS JSON which at every level returns an array. booking_details.destination = recognizer_result.entities.get( "To", {}).get("Airport", [])[:1][:1] booking_details.origin = recognizer_result.entities.get( "From", {}).get("Airport", [])[:1][:1] # This value will be a TIMEX. And we are only interested in a Date so grab the first result and drop the Time part. # TIMEX is a format that represents DateTime expressions that include some ambiguity. e.g. missing a Year. booking_details.travel_date = recognizer_result.entities.get( "datetime", {}).get("timex", [])[:1].split('T')[0] except Exception as e: print(e) return booking_details
def __init__( self, configuration: DefaultConfig, telemetry_client: BotTelemetryClient = None ): self._recognizer = None luis_is_configured = ( configuration.LUIS_APP_ID and configuration.LUIS_API_KEY and configuration.LUIS_API_HOST_NAME ) if luis_is_configured: # Set the recognizer options depending on which endpoint version you want to use e.g v2 or v3. # More details can be found in https://docs.microsoft.com/azure/cognitive-services/luis/luis-migration-api-v3 luis_application = LuisApplication( configuration.LUIS_APP_ID, configuration.LUIS_API_KEY, "https://" + configuration.LUIS_API_HOST_NAME, ) options = LuisPredictionOptions() options.telemetry_client = telemetry_client or NullTelemetryClient() self._recognizer = LuisRecognizer( luis_application, prediction_options=options )
def __init__( self, config: DefaultConfig, conversation_state: ConversationState, user_state: UserState, dialog: Dialog ): luis_application = LuisApplication( config.LUIS_APP_ID, config.LUIS_API_KEY, "https://" + config.LUIS_API_HOST_NAME ) luis_options = LuisPredictionOptions(include_all_intents=True, include_instance_data=True) self.recognizer = LuisRecognizer(luis_application, luis_options, True) self.subscription_key = config.LUIS_API_KEY self.version_id = config.LUIS_APP_VERSION_ID # 可空白或直接填寫一個現有的luis app,不過需要注意其version_id是否與config.py裡的一樣 self.luis_appid = '' # 激活dialog_data.py裡的資訊 self.user_profile_accessor = user_state.create_property("DialogData") if conversation_state is None: raise TypeError("[DialogBot]: Missing parameter. conversation_state is required but None was given") if user_state is None: raise TypeError("[DialogBot]: Missing parameter. user_state is required but None was given") if dialog is None: raise Exception("[DialogBot]: Missing parameter. dialog is required") self.conversation_state = conversation_state self.user_state = user_state self.dialog = dialog
def __init__(self): #connect to LUIS library app luis_app = LuisApplication(CONFIG.LUIS_APP_ID, CONFIG.LUIS_API_KEY, CONFIG.LUIS_API_HOST_NAME) luis_option = LuisPredictionOptions(include_all_intents=True, include_instance_data=True) self.LuisReg = LuisRecognizer(luis_app, luis_option, True)
def __init__(self): luis_app = LuisApplication( "9e445b81-7a4f-40e6-bfbf-81a1ea50a1e9", "dc11dc5d4a854a448842b39c217f064d", "https://westus.api.cognitive.microsoft.com/") luis_option = LuisPredictionOptions(include_all_intents=True, include_instance_data=True) self.LuisReg = LuisRecognizer(luis_app, luis_option, True)
def __init__(self): configuration = DefaultConfig() self._recognizer = None if configuration.LUIS_APP_ID and configuration.LUIS_API_KEY and configuration.LUIS_API_HOST_NAME: luis_application = LuisApplication( configuration.LUIS_APP_ID, configuration.LUIS_API_KEY, "https://" + configuration.LUIS_API_HOST_NAME) self._recognizer = LuisRecognizer(luis_application)
def __init__(self): self.config_reader = ConfigReader() self.configuration = self.config_reader.read_config() self.luis_app_id=self.configuration['LUIS_APP_ID'] self.luis_endpoint_key = self.configuration['LUIS_ENDPOINT_KEY'] self.luis_endpoint = self.configuration['LUIS_ENDPOINT'] self.luis_app = LuisApplication(self.luis_app_id,self.luis_endpoint_key,self.luis_endpoint) self.luis_options = LuisPredictionOptions(include_all_intents=True,include_instance_data=True) self.luis_recognizer = LuisRecognizer(application=self.luis_app,prediction_options=self.luis_options,include_api_results=True)
def __init__(self,constate:ConversationState,userstate:UserState): luis_app = LuisApplication("APP ID","primary starter key","https://westus.api.cognitive.microsoft.com/") luis_option = LuisPredictionOptions(include_all_intents=True,include_instance_data=True) self.LuisReg = LuisRecognizer(luis_app,luis_option,True) self.constate = constate self.userstate = userstate self.conprop = self.constate.create_property("constate") self.userprop = self.userstate.create_property("userstate")
async def on_message_activity(self, turn_context: TurnContext): # First, we use the dispatch model to determine which cognitive service (LUIS or QnA) to use. recognizer_result = await self.recognizer.recognize(turn_context) # Top intent tell us which cognitive service to use. intent = LuisRecognizer.top_intent(recognizer_result) # Next, we call the dispatcher with the top intent. await self._dispatch_to_top_intent(turn_context, intent, recognizer_result)
async def execute_luis_query( configuration, turn_context: TurnContext, telemetry_client: BotTelemetryClient = None, ) -> BookingDetails: """Invoke LUIS service to perform prediction/evaluation of utterance.""" booking_details = BookingDetails() # pylint:disable=broad-except try: luis_application = LuisApplication( configuration.get("LUIS_APP_ID"), configuration.get("LUIS_API_KEY"), configuration.get("LUIS_API_HOST_NAME"), ) options = LuisPredictionOptions() options.telemetry_client = ( telemetry_client if telemetry_client is not None else NullTelemetryClient() ) recognizer = LuisRecognizer(luis_application, prediction_options=options) recognizer_result = await recognizer.recognize(turn_context) print(f"Recognize Result: {recognizer_result}") if recognizer_result.intents: intent = sorted( recognizer_result.intents, key=recognizer_result.intents.get, reverse=True, )[:1][0] if intent == "Book_flight": # We need to get the result from the LUIS JSON which at every level returns an array. to_entities = recognizer_result.entities.get("$instance", {}).get( "To", [] ) if to_entities: booking_details.destination = to_entities[0]["text"] from_entities = recognizer_result.entities.get("$instance", {}).get( "From", [] ) if from_entities: booking_details.origin = from_entities[0]["text"] # This value will be a TIMEX. And we are only interested in a Date so grab the first result and drop the Time part. # TIMEX is a format that represents DateTime expressions that include some ambiguity. e.g. missing a Year. date_entities = recognizer_result.entities.get("$instance", {}).get( "datetime", [] ) if date_entities: booking_details.travel_date = ( None ) # Set when we get a timex format except Exception as exception: print(exception) return booking_details
def test_luis_recognizer_timeout(self): endpoint = "https://westus.api.cognitive.microsoft.com/luis/v2.0/apps/b31aeaf3-3511-495b-a07f-571fc873214b?verbose=true&timezoneOffset=-360&subscription-key=048ec46dc58e495482b0c447cfdbd291&q=" expected_timeout = 300 options_with_timeout = LuisPredictionOptions(timeout=expected_timeout * 1000) recognizer_with_timeout = LuisRecognizer(endpoint, options_with_timeout) self.assertEqual( expected_timeout, recognizer_with_timeout._runtime.config.connection.timeout )
def test_pass_luis_prediction_options_to_recognizer(self): # Arrange my_app = LuisApplication( LuisRecognizerTest._luisAppId, LuisRecognizerTest._subscriptionKey, endpoint=None, ) luis_prediction_options = LuisPredictionOptions( log_personal_information=True, include_all_intents=True, include_instance_data=True ) # Assert recognizer = LuisRecognizer(my_app) merged_options = recognizer._merge_options(luis_prediction_options) self.assertTrue(merged_options.log_personal_information) self.assertTrue(merged_options.include_all_intents) self.assertTrue(merged_options.include_instance_data) self.assertFalse(recognizer._options.log_personal_information) self.assertFalse(recognizer._options.include_all_intents) self.assertFalse(recognizer._options.include_instance_data)
def test_luis_recognizer_construction(self): # Arrange endpoint = "https://westus.api.cognitive.microsoft.com/luis/v2.0/apps/b31aeaf3-3511-495b-a07f-571fc873214b?verbose=true&timezoneOffset=-360&subscription-key=048ec46dc58e495482b0c447cfdbd291&q=" # Act recognizer = LuisRecognizer(endpoint) # Assert app = recognizer._application self.assertEqual("b31aeaf3-3511-495b-a07f-571fc873214b", app.application_id) self.assertEqual("048ec46dc58e495482b0c447cfdbd291", app.endpoint_key) self.assertEqual("https://westus.api.cognitive.microsoft.com", app.endpoint)
async def execute_luis_query( luis_recognizer: LuisRecognizer, turn_context: TurnContext) -> (Intent, object): """ Returns an object with preformatted LUIS results for the bot's dialogs to consume. """ result = None intent = None try: recognizer_result = await luis_recognizer.recognize(turn_context) intent = LuisRecognizer.top_intent(recognizer_result) print("INTENT", intent) if intent == Intent.CREATE_REMINDER.value: result = Reminder() reminder_entities = recognizer_result.entities.get( "$instance", {}).get("reminder_title", []) if len(reminder_entities) > 0: result.title = reminder_entities[0]["text"].title() else: result.title = None date_entities = recognizer_result.entities.get("datetime", []) if date_entities: timex = date_entities[0]["timex"] if timex: result.reminder_time = DatetimeHelper.format_datetime( timex[0]) else: result.reminder_time = None elif intent == Intent.SNOOZE_REMINDER.value: text = turn_context.activity.text result = Reminder() result.id = text.split()[1] date_entities = recognizer_result.entities.get("datetime", []) if date_entities: timex = date_entities[0]["timex"] if timex: result.reminder_time = DatetimeHelper.format_datetime( timex[0]) except Exception as exception: print(exception) return intent, result
def test_dont_pass_luis_prediction_options_to_recognizer(self): # Arrange my_app = LuisApplication( LuisRecognizerTest._luisAppId, LuisRecognizerTest._subscriptionKey, endpoint=None, ) # Assert recognizer = LuisRecognizer(my_app) self.assertFalse(recognizer._options.log_personal_information) self.assertFalse(recognizer._options.include_all_intents) self.assertFalse(recognizer._options.include_instance_data)
def __init__(self, configuration: DefaultConfig): self._recognizer = None luis_is_configured = (configuration.LUIS_APP_ID and configuration.LUIS_API_KEY and configuration.LUIS_API_HOST_NAME) if luis_is_configured: luis_application = LuisApplication( configuration.LUIS_APP_ID, configuration.LUIS_API_KEY, "https://" + configuration.LUIS_API_HOST_NAME, ) self._recognizer = LuisRecognizer(luis_application)
def __init__(self, configuration: dict): self._recognizer = None luis_is_configured = (configuration["LuisAppId"] and configuration["LuisAPIKey"] and configuration["LuisAPIHostName"]) if luis_is_configured: luis_application = LuisApplication( configuration["LuisAppId"], configuration["LuisAPIKey"], "https://" + configuration["LuisAPIHostName"], ) self._recognizer = LuisRecognizer(luis_application)
def __init__(self, configuration: object): self._recognizer = None luis_is_configured = (configuration.luis_app_id and configuration.luis_api_key and configuration.luis_api_host_name) if luis_is_configured: luis_application = LuisApplication( configuration.luis_app_id, configuration.luis_api_key, "https://" + configuration.luis_api_host_name, ) self._recognizer = LuisRecognizer(luis_application)
def test_telemetry_construction(self): # Arrange # Note this is NOT a real LUIS application ID nor a real LUIS subscription-key # theses are GUIDs edited to look right to the parsing and validation code. endpoint = "https://westus.api.cognitive.microsoft.com/luis/v2.0/apps/b31aeaf3-3511-495b-a07f-571fc873214b?verbose=true&timezoneOffset=-360&subscription-key=048ec46dc58e495482b0c447cfdbd291&q=" # Act recognizer = LuisRecognizer(endpoint) # Assert app = recognizer._application self.assertEqual("b31aeaf3-3511-495b-a07f-571fc873214b", app.application_id) self.assertEqual("048ec46dc58e495482b0c447cfdbd291", app.endpoint_key) self.assertEqual("https://westus.api.cognitive.microsoft.com", app.endpoint)
def __init__(self, configuration: dict): self._recognizer = None luis_is_configured = (configuration["LUIS_APP_ID"] and configuration["LUIS_API_KEY"] and configuration["LUIS_API_HOST_NAME"]) if luis_is_configured: luis_application = LuisApplication( configuration["LUIS_APP_ID"], configuration["LUIS_API_KEY"], "https://" + configuration["LUIS_API_HOST_NAME"], ) self._recognizer = LuisRecognizer(luis_application)
def test_empty_endpoint(self): # Arrange my_app = LuisApplication( LuisRecognizerTest._luisAppId, LuisRecognizerTest._subscriptionKey, endpoint="", ) # Assert recognizer = LuisRecognizer(my_app, prediction_options=None) # Assert app = recognizer._application self.assertEqual("https://westus.api.cognitive.microsoft.com", app.endpoint)
def __init__(self, config: DefaultConfig): luis_application = LuisApplication( config.LUIS_APP_ID, config.LUIS_API_KEY, "https://" + config.LUIS_API_HOST_NAME, ) luis_options = LuisPredictionOptions( include_all_intents=True, include_instance_data=True ) self.recognizer = LuisRecognizer(luis_application, luis_options, True) self.fetch_dataset() self._AzMap = AzureMaps(subscription_key=config.AZURE_MAPS_KEY)
def __init__(self, configuration: DefaultConfig()): luis_is_configured = (configuration.LUIS_APP_ID and configuration.LUIS_API_KEY and configuration.LUIS_API_HOST_NAME) if luis_is_configured: # Set the recognizer options depending on which endpoint version you want to use e.g v2 or v3. # More details can be found in https://docs.microsoft.com/azure/cognitive-services/luis/luis-migration-api-v3 luis_application = LuisApplication( configuration.LUIS_APP_ID, configuration.LUIS_API_KEY, "https://" + configuration.LUIS_API_HOST_NAME, ) self._recognizer = LuisRecognizer(luis_application)