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)
