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()
