def test_list_application_from_luis_endpoint_bad_arguments(self) -> None: application_endpoint_data: List[str] = [ "this.is.not.a.uri", "https://westus.api.cognitive.microsoft.com/luis/v2.0/apps/b31aeaf3-3511-495b-a07f-571fc873214b?verbose=true&timezoneOffset=-360&q=", "https://westus.api.cognitive.microsoft.com?verbose=true&timezoneOffset=-360&subscription-key=048ec46dc58e495482b0c447cfdbd291&q=", ] for application_endpoint in application_endpoint_data: with self.subTest(application_endpoint=application_endpoint): with self.assertRaises(ValueError): LuisApplication.from_application_endpoint( application_endpoint)
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 )
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 )
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 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): #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)
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 __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): 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)
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 __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")
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 test_luis_application_construction(self) -> None: model = LuisApplicationTest.get_valid_model() self.assertIsNotNone(model) construction_data: List[Tuple[str, str]] = [ (None, str(uuid4())), ("", str(uuid4())), ("0000", str(uuid4())), (str(uuid4()), None), (str(uuid4()), ""), (str(uuid4()), "000"), ] for app_id, key in construction_data: with self.subTest(app_id=app_id, key=key): with self.assertRaises(ValueError): LuisApplication(app_id, key, LuisApplicationTest.endpoint) luisApp = LuisApplication(str(uuid4()), str(uuid4()), LuisApplicationTest.endpoint) self.assertEqual(LuisApplicationTest.endpoint, luisApp.endpoint)
def __init__(self): config = DefaultConfig() luis_application = LuisApplication( config.LUIS_APP_ID, config.LUIS_API_KEY, config.LUIS_API_HOST_NAME, ) luis_options = LuisPredictionOptions(include_all_intents=True, include_instance_data=True) super().__init__(luis_application, luis_options, True)
def _get_luis_recognizer( cls, recognizer_class: type, options: LuisPredictionOptions = None, include_api_results: bool = False, ) -> LuisRecognizer: luis_app = LuisApplication(cls._luisAppId, cls._subscriptionKey, cls._endpoint) return recognizer_class( luis_app, prediction_options=options, include_api_results=include_api_results, )
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: 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: 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, 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 __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): 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)
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)
def test_list_application_from_luis_endpoint(self) -> None: # 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 app = LuisApplication.from_application_endpoint(endpoint) # Assert 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, 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, conversation_state: ConversationState, user_state: UserState): 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) self.qna_knowledge_base_id = self.configuration["QNA_KNOWLEDGEBASE_ID"] self.qna_endpoint_key = self.configuration["QNA_ENDPOINT_KEY"] self.qna_host = self.configuration["QNA_ENDPOINT_HOST"] self.qna_maker = QnAMaker( QnAMakerEndpoint(knowledge_base_id=self.qna_knowledge_base_id, endpoint_key=self.qna_endpoint_key, host=self.qna_host)) self.log = Log() self.IntentIdentified = False self.intent = 'none' self.stat = 'init' self.city = "" self.score = "" if conversation_state is None: raise TypeError( "[StateManagementBot]: Missing parameter. conversation_state is required but None was given" ) if user_state is None: raise TypeError( "[StateManagementBot]: Missing parameter. user_state is required but None was given" ) self.conversation_state = conversation_state self.user_state = user_state self.conversation_data_accessor = self.conversation_state.create_property( "ConversationData") self.user_profile_accessor = self.user_state.create_property( "UserProfile")
def __init__(self, config: DefaultConfig): self.qna_maker = QnAMaker( QnAMakerEndpoint( knowledge_base_id=config.QNA_KNOWLEDGEBASE_ID, endpoint_key=config.QNA_ENDPOINT_KEY, host=config.QNA_ENDPOINT_HOST, )) # If the includeApiResults parameter is set to true, as shown below, the full response # from the LUIS api will be made available in the properties of the RecognizerResult 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)
def __init__(self, configuration: DefaultConfig): self._recognizer = None self.luis_is_disabled = configuration.LUIS_IS_DISABLED self.luis_is_configured = (configuration.LUIS_APP_ID and configuration.LUIS_API_KEY and configuration.LUIS_API_HOST_NAME) if self.luis_is_configured: # Set the recognizer options depending on which endpoint version you want to use e.g # v2 or v3. luis_application = LuisApplication( configuration.LUIS_APP_ID, configuration.LUIS_API_KEY, "https://" + configuration.LUIS_API_HOST_NAME, ) self._recognizer = LuisRecognizer(luis_application) self._recognizer.luis_trace_label = DeliverySchedulingRecognizer.__name__ LOGGER.debug(msg="LUIS application configured and initialized")
def __init__(self, config: Config): self.qna_maker = QnAMaker( QnAMakerEndpoint( knowledge_base_id=config.QNA_KNOWLEDGEBASE_ID, endpoint_key=config.QNA_ENDPOINT_KEY, host=config.QNA_ENDPOINT_HOST, ), QnAMakerOptions(score_threshold=0.9)) 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.db_func = DB_function() self.favor = my_favorite() self.history = history()